diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000000..041e00f3a8 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,3 @@ +tests/stylo.hpp -diff +tests/headers/* eol=lf +tests/expectations/tests/* eol=lf \ No newline at end of file diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md new file mode 100644 index 0000000000..442e078699 --- /dev/null +++ b/.github/ISSUE_TEMPLATE.md @@ -0,0 +1,61 @@ + + +### Input C/C++ Header + +```C++ +// Insert your minimal C or C++ header here. +// +// It should *NOT* have any `#include`s! Not all systems have the same header +// files, and therefore any `#include` harms reproducibility. Additionally, +// the test case isn't minimal since the included file almost assuredly +// contains things that aren't necessary to reproduce the bug, and makes +// tracking it down much more difficult. +// +// Use the `--dump-preprocessed-input` flag or the +// `bindgen::Builder::dump_preprocessed_input` method to make your test case +// standalone and without `#include`s, and then use C-Reduce to minimize it: +// https://github.com/rust-lang/rust-bindgen/blob/master/CONTRIBUTING.md#using-creduce-to-minimize-test-cases +``` + +### Bindgen Invocation + + + +```Rust +bindgen::Builder::default() + .header("input.h") + .generate() + .unwrap() +``` + +or + +``` +$ bindgen input.h --whatever --flags +``` + +### Actual Results + +``` +Insert panic message and backtrace (set the `RUST_BACKTRACE=1` env var) here. +``` + +and/or + +```rust +// Insert the (incorrect/buggy) generated bindings here +``` + +and/or + +``` +Insert compilation errors generated when compiling the bindings with rustc here +``` + +### Expected Results + + diff --git a/.github/workflows/bindgen.yml b/.github/workflows/bindgen.yml new file mode 100644 index 0000000000..bd1489911e --- /dev/null +++ b/.github/workflows/bindgen.yml @@ -0,0 +1,209 @@ +name: bindgen + +on: + push: + branches: + - main + pull_request: + branches: + - main + merge_group: + branches: + - main + +jobs: + rustfmt: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Install nightly + uses: dtolnay/rust-toolchain@master + with: + toolchain: nightly + components: rustfmt + + - name: Run rustfmt + run: cargo +nightly fmt -- --check + + clippy: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Run clippy + run: cargo clippy --all-targets --workspace --exclude bindgen-integration --exclude tests_expectations -- -D warnings + + msrv: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Read crate metadata + id: metadata + run: echo "rust-version=$(sed -ne 's/rust-version *= *\"\(.*\)\"/\1/p' Cargo.toml)" >> $GITHUB_OUTPUT + + - name: Install msrv for lib + uses: dtolnay/rust-toolchain@master + with: + toolchain: ${{ steps.metadata.outputs.rust-version }} + + - name: Test lib with msrv + run: cargo +${{ steps.metadata.outputs.rust-version }} test --package bindgen + + - name: Install msrv for cli + uses: dtolnay/rust-toolchain@master + with: + toolchain: ${{ steps.metadata.outputs.rust-version }} + + - name: Test cli with msrv + run: cargo +${{ steps.metadata.outputs.rust-version }} build --package bindgen-cli + + minimal: + runs-on: ubuntu-latest + env: + RUSTFLAGS: -D warnings + steps: + - uses: actions/checkout@v4 + + - name: Check without default features + run: cargo check -p bindgen --no-default-features --features=runtime + + docs: + runs-on: ubuntu-latest + env: + RUSTDOCFLAGS: -D warnings + steps: + - uses: actions/checkout@v4 + + - name: Generate documentation for `bindgen` + run: cargo doc --document-private-items --no-deps -p bindgen + + - name: Generate documentation for `bindgen-cli` + run: cargo doc --document-private-items --no-deps -p bindgen-cli + + quickchecking: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + # TODO: Actually run quickchecks once `bindgen` is reliable enough. + - name: Build quickcheck tests + run: cd bindgen-tests/tests/quickchecking && cargo test + + test-expectations: + runs-on: ${{matrix.os}} + strategy: + matrix: + os: [ubuntu-latest, ubuntu-24.04-arm, macos-latest] + steps: + - uses: actions/checkout@v4 + + - name: Test expectations + run: cd bindgen-tests/tests/expectations && cargo test + + test: + runs-on: ${{matrix.platform.os}} + strategy: + matrix: + platform: + - os: ubuntu-latest + libtinfo: libtinfo5_6.3-2ubuntu0.1_amd64.deb + ubuntu_repo: https://mirrors.kernel.org/ubuntu/pool/universe/n/ncurses/ + - os: ubuntu-24.04-arm + libtinfo: libtinfo5_6.3-2ubuntu0.1_arm64.deb + ubuntu_repo: https://ports.ubuntu.com/ubuntu-ports/pool/universe/n/ncurses/ + llvm_version: ["9.0", "16.0"] + release_build: [0, 1] + no_default_features: [0, 1] + # FIXME: There are no pre-built static libclang libraries, so the + # `static` feature is not testable atm. + feature_runtime: [0, 1] + feature_extra_asserts: [0] + + include: + # Test with extra asserts + docs just with latest llvm versions to + # prevent explosion + - platform: + os: ubuntu-latest + libtinfo: libtinfo5_6.3-2ubuntu0.1_amd64.deb + ubuntu_repo: https://mirrors.kernel.org/ubuntu/pool/universe/n/ncurses/ + llvm_version: "16.0" + release_build: 0 + no_default_features: 0 + feature_extra_asserts: 1 + + # Ensure stuff works on macos too + - platform: + os: macos-latest + llvm_version: "16.0" + release_build: 0 + no_default_features: 0 + feature_extra_asserts: 0 + steps: + - uses: actions/checkout@v4 + + - name: Install stable + uses: dtolnay/rust-toolchain@master + with: + toolchain: stable + - name: Install libtinfo + if: startsWith(matrix.platform.os, 'ubuntu') + run: | + wget ${{matrix.platform.ubuntu_repo}}${{matrix.platform.libtinfo}} + sudo dpkg -i ${{matrix.platform.libtinfo}} + - name: Install LLVM and Clang + uses: KyleMayes/install-llvm-action@v2.0.5 + with: + version: ${{matrix.llvm_version}} + - name: Run all the tests + env: + GITHUB_ACTIONS_OS: ${{matrix.platform.os}} + BINDGEN_RELEASE_BUILD: ${{matrix.release_build}} + BINDGEN_FEATURE_RUNTIME: ${{matrix.feature_runtime}} + BINDGEN_FEATURE_EXTRA_ASSERTS: ${{matrix.feature_extra_asserts}} + BINDGEN_NO_DEFAULT_FEATURES: ${{matrix.no_default_features}} + BINDGEN_RUST_FOR_LINUX_TEST: ${{startsWith(matrix.platform.os, 'ubuntu') && matrix.llvm_version == '16.0' && matrix.feature_extra_asserts == 0 && 1 || 0}} + run: ./ci/test.sh + + test-book: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + # NOTE(emilio): Change deploy-book as well if you change this. + - name: Test book + run: | + curl -L https://github.com/rust-lang/mdBook/releases/download/v0.4.5/mdbook-v0.4.5-x86_64-unknown-linux-gnu.tar.gz | tar xz + ./mdbook build book + ./mdbook test book + + # FIXME(pvdrz): this should be done inside `bindgen-test` instead + test-no-headers: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Test `--help` + run: cargo run -- --help + + - name: Test `--version` + run: cargo run -- --version + + - name: Test `--generate-shell-completions` + run: cargo run -- --generate-shell-completions=bash + + # One job that "summarizes" the success state of this pipeline. This can then + # be added to branch protection, rather than having to add each job + # separately. + success: + runs-on: ubuntu-latest + needs: [rustfmt, clippy, msrv, minimal, docs, quickchecking, test-expectations, test, test-book, test-no-headers] + # GitHub branch protection is exceedingly silly and treats "jobs skipped + # because a dependency failed" as success. So we have to do some + # contortions to ensure the job fails if any of its dependencies fails. + if: always() # make sure this is never "skipped" + steps: + # Manually check the status of all dependencies. `if: failure()` does not work. + - name: check if any dependency failed + run: jq --exit-status 'all(.result == "success")' <<< '${{ toJson(needs) }}' diff --git a/.github/workflows/bump-version.yml b/.github/workflows/bump-version.yml new file mode 100644 index 0000000000..56a264f7f7 --- /dev/null +++ b/.github/workflows/bump-version.yml @@ -0,0 +1,68 @@ +name: Bump version for release + +on: + workflow_dispatch: + inputs: + level: + description: | + Select the level of the release + required: true + type: choice + options: + - minor + - patch + +jobs: + bump-version: + permissions: + id-token: write + pull-requests: write + contents: write + + runs-on: ubuntu-latest + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Configure gitsign + uses: chainguard-dev/actions/setup-gitsign@main + + - name: Install cargo-release + uses: taiki-e/install-action@v1 + with: + tool: cargo-release + + - name: Install sd + uses: taiki-e/install-action@v1 + with: + tool: sd + + - name: Install npm + uses: actions/setup-node@v4 + + - name: Install doctoc + run: npm install doctoc + + - name: Bump version + run: | + cargo release version ${{ inputs.level }} --execute --no-confirm + + - name: Extract version + run: | + echo "version=$(cargo pkgid -p bindgen | cut -d '#' -f 2)" >> $GITHUB_ENV + + - name: Update changelog + run: | + sd "# Unreleased" "# Unreleased\n## Added\n## Changed\n## Removed\n## Fixed\n## Security\n\n# ${{ env.version }} ($(date -I))" CHANGELOG.md + ./node_modules/doctoc/doctoc.js CHANGELOG.md + + - name: Create PR + uses: peter-evans/create-pull-request@v5 + with: + token: ${{ secrets.GITHUB_TOKEN }} + branch: bump-version/${{ env.version }} + base: main + commit-message: "Bump crates version to ${{ env.version }}" + title: "Bump crates version to ${{ env.version }}" + body: | + This pull request was created automatically by GitHub Actions. diff --git a/.github/workflows/create-tag.yml b/.github/workflows/create-tag.yml new file mode 100644 index 0000000000..f636991c38 --- /dev/null +++ b/.github/workflows/create-tag.yml @@ -0,0 +1,49 @@ +name: Create tag for release + +on: + pull_request: + types: + - closed + workflow_dispatch: + inputs: + commit: + description: 'Commit hash' + required: true + type: string +jobs: + create-tag: + if: >- + (inputs.commit || false) || + (github.event.pull_request.merged == true && + github.event.pull_request.user.login == 'github-actions' && + github.event.pull_request.head.repo.full_name == github.event.pull_request.base.repo.full_name && + startsWith(github.event.pull_request.head.ref, 'bump-version') ) + runs-on: ubuntu-latest + steps: + - name: Checkout code + uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Compute the commit + run: | + if [[ -z "${{ inputs.commit }}" ]]; then + COMMIT=$(git rev-parse ${{ github.sha }}^@ | grep -Fvx ${{ github.event.pull_request.head.sha }}) + else + COMMIT="${{ inputs.commit }}" + fi + echo "commit=$COMMIT" >> $GITHUB_ENV + + - name: Install rust toolchain + uses: dtolnay/rust-toolchain@stable + + - name: Extract version + run: | + echo "version=$(cargo pkgid -p bindgen | cut -d '#' -f 2)" >> $GITHUB_ENV + + - name: Create tag + uses: mathieudutour/github-tag-action@v6.2 + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + commit_sha: ${{ env.commit }} + custom_tag: ${{ env.version }} diff --git a/.github/workflows/deploy-book.yml b/.github/workflows/deploy-book.yml new file mode 100644 index 0000000000..7b8cacc55d --- /dev/null +++ b/.github/workflows/deploy-book.yml @@ -0,0 +1,27 @@ +name: Deploy book + +on: + push: + branches: + - main + +jobs: + deploy-book: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + persist-credentials: false + + - name: Test book + run: | + curl -L https://github.com/rust-lang/mdBook/releases/download/v0.4.34/mdbook-v0.4.34-x86_64-unknown-linux-gnu.tar.gz | tar xz + ./mdbook build book + ./mdbook test book + + - name: Deploy book + uses: JamesIves/github-pages-deploy-action@3.7.1 + with: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + BRANCH: gh-pages + FOLDER: book/book diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml new file mode 100644 index 0000000000..d8602f9ad9 --- /dev/null +++ b/.github/workflows/publish.yml @@ -0,0 +1,27 @@ +# This is triggered after the Release workflow successfully completes its run +name: Publish on crates.io +on: + workflow_run: + workflows: + - Release + types: + - completed +env: + CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }} +jobs: + cargo-publish: + runs-on: ubuntu-latest + if: ${{ !github.event.pull_request && (github.event.workflow_run.conclusion == 'success') && (github.event.workflow.name == 'Release') }} + steps: + - name: Print workflow event name + run: echo "${{ github.event.workflow.name }}" + - name: Checkout sources + uses: actions/checkout@v4 + - name: Install stable toolchain + uses: dtolnay/rust-toolchain@master + with: + toolchain: stable + - name: Publish bindgen (lib) + run: cargo publish --package bindgen --token ${CARGO_REGISTRY_TOKEN} + - name: Publish bindgen-cli + run: cargo publish --package bindgen-cli --token ${CARGO_REGISTRY_TOKEN} diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000000..6620b80c98 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,291 @@ +# This file was autogenerated by dist: https://opensource.axo.dev/cargo-dist/ +# +# Copyright 2022-2024, axodotdev +# SPDX-License-Identifier: MIT or Apache-2.0 +# +# CI that: +# +# * checks for a Git Tag that looks like a release +# * builds artifacts with dist (archives, installers, hashes) +# * uploads those artifacts to temporary workflow zip +# * on success, uploads the artifacts to a GitHub Release +# +# Note that the GitHub Release will be created with a generated +# title/body based on your changelogs. + +name: Release +permissions: + "contents": "write" + +# This task will run whenever you push a git tag that looks like a version +# like "1.0.0", "v0.1.0-prerelease.1", "my-app/0.1.0", "releases/v1.0.0", etc. +# Various formats will be parsed into a VERSION and an optional PACKAGE_NAME, where +# PACKAGE_NAME must be the name of a Cargo package in your workspace, and VERSION +# must be a Cargo-style SemVer Version (must have at least major.minor.patch). +# +# If PACKAGE_NAME is specified, then the announcement will be for that +# package (erroring out if it doesn't have the given version or isn't dist-able). +# +# If PACKAGE_NAME isn't specified, then the announcement will be for all +# (dist-able) packages in the workspace with that version (this mode is +# intended for workspaces with only one dist-able package, or with all dist-able +# packages versioned/released in lockstep). +# +# If you push multiple tags at once, separate instances of this workflow will +# spin up, creating an independent announcement for each one. However, GitHub +# will hard limit this to 3 tags per commit, as it will assume more tags is a +# mistake. +# +# If there's a prerelease-style suffix to the version, then the release(s) +# will be marked as a prerelease. +on: + pull_request: + push: + tags: + - '**[0-9]+.[0-9]+.[0-9]+*' + +jobs: + # Run 'dist plan' (or host) to determine what tasks we need to do + plan: + runs-on: "ubuntu-22.04" + outputs: + val: ${{ steps.plan.outputs.manifest }} + tag: ${{ !github.event.pull_request && github.ref_name || '' }} + tag-flag: ${{ !github.event.pull_request && format('--tag={0}', github.ref_name) || '' }} + publishing: ${{ !github.event.pull_request }} + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + steps: + - uses: actions/checkout@v4 + with: + submodules: recursive + - name: Install dist + # we specify bash to get pipefail; it guards against the `curl` command + # failing. otherwise `sh` won't catch that `curl` returned non-0 + shell: bash + run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.28.0/cargo-dist-installer.sh | sh" + - name: Cache dist + uses: actions/upload-artifact@v4 + with: + name: cargo-dist-cache + path: ~/.cargo/bin/dist + # sure would be cool if github gave us proper conditionals... + # so here's a doubly-nested ternary-via-truthiness to try to provide the best possible + # functionality based on whether this is a pull_request, and whether it's from a fork. + # (PRs run on the *source* but secrets are usually on the *target* -- that's *good* + # but also really annoying to build CI around when it needs secrets to work right.) + - id: plan + run: | + dist ${{ (!github.event.pull_request && format('host --steps=create --tag={0}', github.ref_name)) || 'plan' }} --output-format=json > plan-dist-manifest.json + echo "dist ran successfully" + cat plan-dist-manifest.json + echo "manifest=$(jq -c "." plan-dist-manifest.json)" >> "$GITHUB_OUTPUT" + - name: "Upload dist-manifest.json" + uses: actions/upload-artifact@v4 + with: + name: artifacts-plan-dist-manifest + path: plan-dist-manifest.json + + # Build and packages all the platform-specific things + build-local-artifacts: + name: build-local-artifacts (${{ join(matrix.targets, ', ') }}) + # Let the initial task tell us to not run (currently very blunt) + needs: + - plan + if: ${{ fromJson(needs.plan.outputs.val).ci.github.artifacts_matrix.include != null && (needs.plan.outputs.publishing == 'true' || fromJson(needs.plan.outputs.val).ci.github.pr_run_mode == 'upload') }} + strategy: + fail-fast: false + # Target platforms/runners are computed by dist in create-release. + # Each member of the matrix has the following arguments: + # + # - runner: the github runner + # - dist-args: cli flags to pass to dist + # - install-dist: expression to run to install dist on the runner + # + # Typically there will be: + # - 1 "global" task that builds universal installers + # - N "local" tasks that build each platform's binaries and platform-specific installers + matrix: ${{ fromJson(needs.plan.outputs.val).ci.github.artifacts_matrix }} + runs-on: ${{ matrix.runner }} + container: ${{ matrix.container && matrix.container.image || null }} + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + BUILD_MANIFEST_NAME: target/distrib/${{ join(matrix.targets, '-') }}-dist-manifest.json + steps: + - name: enable windows longpaths + run: | + git config --global core.longpaths true + - uses: actions/checkout@v4 + with: + submodules: recursive + - name: Install Rust non-interactively if not already installed + if: ${{ matrix.container }} + run: | + if ! command -v cargo > /dev/null 2>&1; then + curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y + echo "$HOME/.cargo/bin" >> $GITHUB_PATH + fi + - name: Install dist + run: ${{ matrix.install_dist.run }} + # Get the dist-manifest + - name: Fetch local artifacts + uses: actions/download-artifact@v4 + with: + pattern: artifacts-* + path: target/distrib/ + merge-multiple: true + - name: Install dependencies + run: | + ${{ matrix.packages_install }} + - name: Build artifacts + run: | + # Actually do builds and make zips and whatnot + dist build ${{ needs.plan.outputs.tag-flag }} --print=linkage --output-format=json ${{ matrix.dist_args }} > dist-manifest.json + echo "dist ran successfully" + - id: cargo-dist + name: Post-build + # We force bash here just because github makes it really hard to get values up + # to "real" actions without writing to env-vars, and writing to env-vars has + # inconsistent syntax between shell and powershell. + shell: bash + run: | + # Parse out what we just built and upload it to scratch storage + echo "paths<> "$GITHUB_OUTPUT" + dist print-upload-files-from-manifest --manifest dist-manifest.json >> "$GITHUB_OUTPUT" + echo "EOF" >> "$GITHUB_OUTPUT" + + cp dist-manifest.json "$BUILD_MANIFEST_NAME" + - name: "Upload artifacts" + uses: actions/upload-artifact@v4 + with: + name: artifacts-build-local-${{ join(matrix.targets, '_') }} + path: | + ${{ steps.cargo-dist.outputs.paths }} + ${{ env.BUILD_MANIFEST_NAME }} + + # Build and package all the platform-agnostic(ish) things + build-global-artifacts: + needs: + - plan + - build-local-artifacts + runs-on: "ubuntu-22.04" + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + BUILD_MANIFEST_NAME: target/distrib/global-dist-manifest.json + steps: + - uses: actions/checkout@v4 + with: + submodules: recursive + - name: Install cached dist + uses: actions/download-artifact@v4 + with: + name: cargo-dist-cache + path: ~/.cargo/bin/ + - run: chmod +x ~/.cargo/bin/dist + # Get all the local artifacts for the global tasks to use (for e.g. checksums) + - name: Fetch local artifacts + uses: actions/download-artifact@v4 + with: + pattern: artifacts-* + path: target/distrib/ + merge-multiple: true + - id: cargo-dist + shell: bash + run: | + dist build ${{ needs.plan.outputs.tag-flag }} --output-format=json "--artifacts=global" > dist-manifest.json + echo "dist ran successfully" + + # Parse out what we just built and upload it to scratch storage + echo "paths<> "$GITHUB_OUTPUT" + jq --raw-output ".upload_files[]" dist-manifest.json >> "$GITHUB_OUTPUT" + echo "EOF" >> "$GITHUB_OUTPUT" + + cp dist-manifest.json "$BUILD_MANIFEST_NAME" + - name: "Upload artifacts" + uses: actions/upload-artifact@v4 + with: + name: artifacts-build-global + path: | + ${{ steps.cargo-dist.outputs.paths }} + ${{ env.BUILD_MANIFEST_NAME }} + # Determines if we should publish/announce + host: + needs: + - plan + - build-local-artifacts + - build-global-artifacts + # Only run if we're "publishing", and only if local and global didn't fail (skipped is fine) + if: ${{ always() && needs.plan.outputs.publishing == 'true' && (needs.build-global-artifacts.result == 'skipped' || needs.build-global-artifacts.result == 'success') && (needs.build-local-artifacts.result == 'skipped' || needs.build-local-artifacts.result == 'success') }} + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + runs-on: "ubuntu-22.04" + outputs: + val: ${{ steps.host.outputs.manifest }} + steps: + - uses: actions/checkout@v4 + with: + submodules: recursive + - name: Install cached dist + uses: actions/download-artifact@v4 + with: + name: cargo-dist-cache + path: ~/.cargo/bin/ + - run: chmod +x ~/.cargo/bin/dist + # Fetch artifacts from scratch-storage + - name: Fetch artifacts + uses: actions/download-artifact@v4 + with: + pattern: artifacts-* + path: target/distrib/ + merge-multiple: true + - id: host + shell: bash + run: | + dist host ${{ needs.plan.outputs.tag-flag }} --steps=upload --steps=release --output-format=json > dist-manifest.json + echo "artifacts uploaded and released successfully" + cat dist-manifest.json + echo "manifest=$(jq -c "." dist-manifest.json)" >> "$GITHUB_OUTPUT" + - name: "Upload dist-manifest.json" + uses: actions/upload-artifact@v4 + with: + # Overwrite the previous copy + name: artifacts-dist-manifest + path: dist-manifest.json + # Create a GitHub Release while uploading all files to it + - name: "Download GitHub Artifacts" + uses: actions/download-artifact@v4 + with: + pattern: artifacts-* + path: artifacts + merge-multiple: true + - name: Cleanup + run: | + # Remove the granular manifests + rm -f artifacts/*-dist-manifest.json + - name: Create GitHub Release + env: + PRERELEASE_FLAG: "${{ fromJson(steps.host.outputs.manifest).announcement_is_prerelease && '--prerelease' || '' }}" + ANNOUNCEMENT_TITLE: "${{ fromJson(steps.host.outputs.manifest).announcement_title }}" + ANNOUNCEMENT_BODY: "${{ fromJson(steps.host.outputs.manifest).announcement_github_body }}" + RELEASE_COMMIT: "${{ github.sha }}" + run: | + # Write and read notes from a file to avoid quoting breaking things + echo "$ANNOUNCEMENT_BODY" > $RUNNER_TEMP/notes.txt + + gh release create "${{ needs.plan.outputs.tag }}" --target "$RELEASE_COMMIT" $PRERELEASE_FLAG --title "$ANNOUNCEMENT_TITLE" --notes-file "$RUNNER_TEMP/notes.txt" artifacts/* + + announce: + needs: + - plan + - host + # use "always() && ..." to allow us to wait for all publish jobs while + # still allowing individual publish jobs to skip themselves (for prereleases). + # "host" however must run to completion, no skipping allowed! + if: ${{ always() && needs.host.result == 'success' }} + runs-on: "ubuntu-22.04" + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + steps: + - uses: actions/checkout@v4 + with: + submodules: recursive diff --git a/.gitignore b/.gitignore index f54aca9873..a610640e5e 100644 --- a/.gitignore +++ b/.gitignore @@ -1,9 +1,25 @@ -bindgen -libbindgen* - # Cargo target/ -Cargo.lock *~ +bindgen-integration/Cargo.lock +bindgen-tests/tests/expectations/Cargo.lock +bindgen-tests/tests/quickchecking/Cargo.lock #*# +# Test script output +ir.dot +ir.png + +# Output of the --dump-preprocessed-input flag. +__bindgen.* + +# Generated by C-Smith +csmith-fuzzing/platform.info + +# Backups of test cases from C-Reduce +**/*.orig + +# node.js files +node_modules +package-lock.json +package.json diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index 5d3395e592..0000000000 --- a/.travis.yml +++ /dev/null @@ -1,52 +0,0 @@ -language: rust -addons: - apt: - sources: - - llvm-toolchain-precise-3.8 - - ubuntu-toolchain-r-test - packages: - - libclang-3.8-dev - - llvm-3.8-dev -env: - - LLVM_VERSION=3.8 -rust: - - stable - - nightly -cache: - directories: - - $HOME/.cargo - -before_install: - - - if [ "${TRAVIS_OS_NAME}" = "osx" ]; then - if [ "${LLVM_VERSION}" != "devtools" ]; then - brew update >/dev/null; - brew install llvm3${LLVM_VERSION#3.}; - fi - fi - -before_script: - - - if [ "${TRAVIS_OS_NAME}" = "linux" ]; then - export LIBCLANG_PATH=/usr/lib/llvm-${LLVM_VERSION}/lib; - elif [ "${TRAVIS_OS_NAME}" = "osx" ]; then - if [ "${LLVM_VERSION}" = "devtools" ]; then - export LIBCLANG_PATH=/Library/Developer/CommandLineTools/usr/lib; - else - export LIBCLANG_PATH=`brew --prefix llvm3${LLVM_VERSION#3.}`/lib/llvm-${LLVM_VERSION}/lib; - fi - fi - - echo $LIBCLANG_PATH - -script: - - cargo build --verbose --features llvm_stable - - cargo test --features llvm_stable - - cargo build --release --verbose --features llvm_stable - - cargo test --release --features llvm_stable - - git add -A - - git diff @ - - git diff-index --quiet HEAD - - cargo build --features "llvm_stable _docs" - -notifications: - webhooks: http://build.servo.org:54856/travis diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000000..74ff973751 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,1947 @@ + + + +- [Unreleased](#unreleased) + - [Added](#added) + - [Changed](#changed) + - [Removed](#removed) + - [Fixed](#fixed) + - [Security](#security) +- [0.72.0 (2025-06-08)](#0720-2025-06-08) + - [Added](#added-1) + - [Changed](#changed-1) + - [Removed](#removed-1) + - [Fixed](#fixed-1) +- [v0.71.1 (2024-12-09)](#v0711-2024-12-09) + - [Fixed](#fixed-2) +- [0.71.0 (2024-12-06)](#0710-2024-12-06) + - [Added](#added-2) + - [Changed](#changed-2) + - [Removed](#removed-2) + - [Fixed](#fixed-3) +- [0.70.1 (2024-08-20)](#0701-2024-08-20) + - [Added](#added-3) + - [Changed](#changed-3) + - [Removed](#removed-3) + - [Fixed](#fixed-4) + - [Security](#security-1) +- [0.70.0 (2024-08-16)](#0700-2024-08-16) + - [Added](#added-4) + - [Changed](#changed-4) + - [Removed](#removed-4) + - [Fixed](#fixed-5) + - [Security](#security-2) +- [0.69.4 (2024-02-04)](#0694-2024-02-04) + - [Added](#added-5) + - [Changed](#changed-5) + - [Removed](#removed-5) + - [Fixed](#fixed-6) + - [Security](#security-3) +- [0.69.3 (2024-02-04)](#0693-2024-02-04) + - [Added](#added-6) + - [Changed](#changed-6) + - [Removed](#removed-6) + - [Fixed](#fixed-7) + - [Security](#security-4) +- [0.69.2 (2024-01-13)](#0692-2024-01-13) + - [Added](#added-7) + - [Changed](#changed-7) + - [Removed](#removed-7) + - [Fixed](#fixed-8) + - [Security](#security-5) +- [0.69.1 (2023-11-02)](#0691-2023-11-02) + - [Fixed](#fixed-9) +- [0.69.0 (2023-11-01)](#0690-2023-11-01) + - [Added](#added-8) + - [Changed](#changed-8) + - [Removed](#removed-8) + - [Fixed](#fixed-10) + - [Security](#security-6) +- [0.68.1](#0681) + - [Fixed](#fixed-11) +- [0.68.0](#0680) + - [Added](#added-9) + - [Changed](#changed-9) + - [Removed](#removed-9) + - [Fixed](#fixed-12) +- [0.67.0](#0670) +- [0.66.1](#0661) + - [Removed](#removed-10) +- [0.66.0](#0660) + - [Added](#added-10) + - [Changed](#changed-10) + - [Removed](#removed-11) +- [0.65.1](#0651) + - [Fixed](#fixed-13) +- [0.65.0](#0650) + - [Added](#added-11) + - [Changed](#changed-11) + - [Removed](#removed-12) +- [0.64.0](#0640) + - [Added](#added-12) + - [Changed](#changed-12) +- [0.63.0](#0630) + - [Added](#added-13) + - [Changed](#changed-13) + - [Removed](#removed-13) +- [0.62.0](#0620) + - [Added](#added-14) + - [Changed](#changed-14) + - [Fixed](#fixed-14) +- [0.61.0](#0610) + - [Added](#added-15) + - [Changed](#changed-15) + - [Fixed](#fixed-15) +- [0.60.1](#0601) + - [Fixed](#fixed-16) +- [0.60.0](#0600) + - [Added](#added-16) + - [Fixed](#fixed-17) + - [Changed](#changed-16) + - [Removed](#removed-14) +- [0.59.2](#0592) +- [0.59.1](#0591) + - [Fixed](#fixed-18) +- [0.59.0](#0590) + - [Added](#added-17) + - [Fixed](#fixed-19) + - [Changed](#changed-17) +- [0.58.1](#0581) + - [Added](#added-18) +- [0.58.0](#0580) + - [Added](#added-19) + - [Fixed](#fixed-20) + - [Changed](#changed-18) + - [Deprecated](#deprecated) + - [Removed](#removed-15) + - [Fixed](#fixed-21) + - [Security](#security-7) +- [0.57.0](#0570) + - [Added](#added-20) + - [Fixed](#fixed-22) +- [0.56.0](#0560) + - [Added](#added-21) + - [Changed](#changed-19) + - [Fixed](#fixed-23) +- [0.55.1](#0551) + - [Fixed](#fixed-24) +- [0.55.0](#0550) + - [Removed](#removed-16) + - [Added](#added-22) + - [Changed](#changed-20) + - [Fixed](#fixed-25) +- [0.54.1](#0541) + - [Added](#added-23) + - [Changed](#changed-21) + - [Fixed](#fixed-26) +- [0.54.0](#0540) + - [Added](#added-24) + - [Changed](#changed-22) + - [Fixed](#fixed-27) +- [0.53.3](#0533) + - [Added](#added-25) + - [Fixed](#fixed-28) +- [0.53.2](#0532) + - [Changed](#changed-23) +- [0.53.1](#0531) + - [Added](#added-26) +- [0.53.0](#0530) + - [Added](#added-27) + - [Changed](#changed-24) + - [Fixed](#fixed-29) +- [0.52.0](#0520) + - [Added](#added-28) + - [Changed](#changed-25) + - [Fixed](#fixed-30) +- [0.51.1](#0511) + - [Fixed](#fixed-31) + - [Changed](#changed-26) +- [0.51.0](#0510) + - [Fixed](#fixed-32) + - [Changed](#changed-27) + - [Added](#added-29) +- [0.50.0](#0500) + - [Added](#added-30) +- [0.49.3](#0493) + - [Added](#added-31) +- [0.49.2](#0492) + - [Changed](#changed-28) +- [0.49.1](#0491) + - [Fixed](#fixed-33) + - [Changed](#changed-29) +- [0.49.0](#0490) + - [Added](#added-32) + - [Fixed](#fixed-34) + - [Changed](#changed-30) +- [0.48.1](#0481) + - [Fixed](#fixed-35) +- [0.48.0](#0480) + - [Changed](#changed-31) + - [Fixed](#fixed-36) +- [0.47.4](#0474) + - [Added](#added-33) +- [0.47.3](#0473) + - [Changed](#changed-32) +- [0.47.2](#0472) + - [Fixed](#fixed-37) +- [0.47.1](#0471) + - [Changed](#changed-33) + - [Fixed](#fixed-38) +- [0.47.0](#0470) + - [Changed](#changed-34) + - [Fixed](#fixed-39) +- [0.33.1 .. 0.46.0](#0331--0460) + - [Added](#added-34) + - [Removed](#removed-17) + - [Changed](#changed-35) + - [Fixed](#fixed-40) +- [0.33.1](#0331) + - [Fixed](#fixed-41) +- [0.33.0](#0330) +- [0.32.2](#0322) + - [Fixed](#fixed-42) +- [0.32.1](#0321) + - [Fixed](#fixed-43) +- [0.32.0](#0320) + - [Added](#added-35) + - [Changed](#changed-36) + - [Fixed](#fixed-44) +- [0.31.0](#0310) + - [Added](#added-36) + - [Changed](#changed-37) + - [Deprecated](#deprecated-1) + - [Removed](#removed-18) + - [Fixed](#fixed-45) +- [0.30.0](#0300) + - [Added](#added-37) + - [Changed](#changed-38) + - [Deprecated](#deprecated-2) + - [Fixed](#fixed-46) +- [0.29.0](#0290) + - [Added](#added-38) + - [Changed](#changed-39) + - [Fixed](#fixed-47) + + + +-------------------------------------------------------------------------------- +# Unreleased +## Added +## Changed +## Removed +- Removed support for generating code for rustc versions < 1.51. +## Fixed +- Typo in code for `--rustified-non-exhaustive-enums` (#3266) +## Security + +# 0.72.0 (2025-06-08) + +## Added + + * Report enums in ParseCallbacks. + * Refactor item_name method to use ItemInfo struct. + * Add callback to modify contents of macro + * Discovery callbacks for functions and methods. + * Options to generate uncallable C++ functions. + * Provide option to get real virtual fn receiver. + +## Changed + + * Generate bindings compatible with current rustc version by default. + +## Removed + + * Remove unused which-rustfmt feature + * Remove warning for opaque forward declarations + +## Fixed + + * More sophisticated handling of the triple in rust_to_clang_target + * Rename *-apple-ios-sim to ...simulator + * Fix OpenCL vectors that use "ext_vector_type". + * Fix union layout when it contains 0 sized array. + * Avoid crashing on variadic unions without layout information. + * Distinguish char16_t. + * Fix bugs in --clang-macro-fallback + * Add missed unsafe in the raw_set_bit function + * Use link_name for dynamic library loading + * Add "gen" to list of rust keywords in 'rust_mangle' + * Use appropriate `rustfmt --format ...` param + +# v0.71.1 (2024-12-09) +## Fixed +- Fix `--version` and `--generate-shell-completions` (#3040) + +# 0.71.0 (2024-12-06) +## Added +- Add the `ParseCallbacks::new_item_found` callback to expose the original and final name of structs, unions and enums (#2658). +- Add the `field_type_name` field to `FieldInfo` to expose the name of the type of a field (#2863) +- Add support for custom attributes with the `--with-attribute-custom` flag (#2866) +- Allow setting `--rust-target` to any Rust version supported by bindgen (#2993) +- Use c-string literals if the `--generate-cstr` flag is used for Rust targets after 1.77 under the 2021 edition (#2996) +- Add the `--rust-edition` flag which allows to select which Rust edition to target. (#3002, #3013) +- Use `unsafe extern` instead of `extern` in blocks for any Rust target after 1.82. (#3015) +## Changed +- The `--wrap-static-fns` related options no longer require the experimental feature or flag (#2928) +- Use the `Display` implementation instead of the `Debug` one for `BindgenError` in `bindgen-cli` (#3005) +## Removed +- Dropped support for any Clang versions strictly lower than 9.0 (#2932) +- Dropped support for any Rust version strictly lower than 1.33 (#2993) +## Fixed +- Represent opaque types in a FFI-safe way (#2880) +- Use the underlying type of any atomic type instead of panicking (#2920) +- Use the right characters for newlines on windows (#2923) +- Inlined namespaces are properly recognized now (#2950) +- Unsafe calls to `libloading` are now wrapped in `unsafe` blocks when using dynamic loading (#2961) +- The `ParseCallbacks::field_visibility` callback is now called for newtypes as well (#2967) +- Gate the use of the `addr_of` and `addr_of_mut` macros under the 1.51 rust version (#2988) + +# 0.70.1 (2024-08-20) +## Added +## Changed +## Removed +## Fixed +- Fix regression where the `const` layout tests were triggering the `unnecessary_operation` and `identity_op` clippy warnings. +## Security + +# 0.70.0 (2024-08-16) +## Added +- Add target mappings for riscv64imac and riscv32imafc. +- Add a complex macro fallback API (#2779). +- Add option to use DST structs for flexible arrays (--flexarray-dst, #2772). +- Add option to dynamically load variables (#2812). +- Add option in CLI to use rustified non-exhaustive enums (--rustified-non-exhaustive-enum, #2847). +- Add field_type_name to FieldInfo. +## Changed +- Remove which and lazy-static dependencies (#2809, #2817). +- Generate compile-time layout tests (#2787). +- Print `bindgen-cli` errors to stderr instead of stdout (#2840) +## Removed +## Fixed +- Fix `--formatter=prettyplease` not working in `bindgen-cli` by adding `prettyplease` feature and + enabling it by default for `bindgen-cli` (#2789) . +- Fix `--allowlist-item` so anonymous enums are no longer ignored (#2827). +- Use clang_getFileLocation instead of clang_getSpellingLocation to fix clang-trunk (#2824). +- Fix generated constants: `f64::INFINITY`, `f64::NEG_ INFINITY`, `f64::NAN` (#2854). +## Security +- Update `tempfile` and `rustix` due to [GHSA-c827-hfw6-qwvm](https://github.com/advisories/GHSA-c827-hfw6-qwvm). + +# 0.69.4 (2024-02-04) +## Added +## Changed +- Allow older itertools. (#2745) +## Removed +## Fixed +## Security + +# 0.69.3 (2024-02-04) +## Added + +- Added blocklist_var (#2731) +- Stabilized thiscall_abi (#2661) + +## Changed + +- Use CR consistently on windows (#2698) +- Replaced peeking_take_while by itertools (#2724) + +## Removed +## Fixed + +- Try to avoid repr(packed) for explicitly aligned types when not needed (#2734) +- Improved destructor handling on Windows (#2663) +- Support Float16 (#2667) +- Fix alignment contribution from bitfields (#2680) +- Fixed msrv build. + +## Security + +- Updated shlex dependency (RUSTSEC-2024-0006) + +# 0.69.2 (2024-01-13) +## Added +## Changed +## Removed +## Fixed +- Fixed generation of extern "C" blocks with llvm 18+. See #2689. +## Security + +# 0.69.1 (2023-11-02) + +## Fixed +- Allow to run `bindgen -v` without an input header argument. + +# 0.69.0 (2023-11-01) + +## Added +- Added the `ParseCallbacks::header_file` callback which runs on every filename passed to `Builder::header`. +- Added the `CargoCallbacks::new` constructor which emits a cargo-rerun line + for every input header file by default. +- Added the `CargoCallbacks::rerun_on_header_files` method to configure whether + a cargo-rerun line should be emitted for every input header file. +## Changed +- The `--wrap-static-fns` feature was updated so function types that has no + argument use `void` as its sole argument. +- `CargoCallbacks` is no longer a [unit-like + struct](https://doc.rust-lang.org/reference/items/structs.html) and the + `CargoCallbacks` constant was added to mitigate the breaking nature of this + change. This constant has been marked as deprecated and users will have to + use the new `CargoCallbacks::new` method in the future. +## Removed +## Fixed +- Allow compiling `bindgen-cli` with a static libclang. +- Emit an opaque integer type for pointer types that don't have the same size + as the target's pointer size. +- Avoid escaping Objective-C method names unless they are `Self`, `self`, + `crate` or `super`. +## Security + +# 0.68.1 + +## Fixed +- Fixed errors on the windows artifact build process. + +# 0.68.0 + +## Added +- The `system` ABI is now supported as an option for the `--override-abi` flag. +- The `allowlist_item` method and the `--allowlist-item` flag have been + included to filter items regardless or their kind. +- Include installers as release artifacts on Github. +## Changed +- The `Clone` implementation for `_BindgenUnionField` has been changed to pass + the `incorrect_clone_impl_on_copy_type` Clippy lint. +- The `c_unwind` ABI can be used without a feature gate for any Rust target version + equal to or greater than 1.71. + This comes as a result of the ABI being stabilised (in Rust 1.71). +- Formatting changes when using prettyplease as a formatter due to a new + prettyplease version. +- Avoid generating invalid `CStr` constants when using the `--generate-cstr` + option. +## Removed +- The `extra_assert` and `extra_assert_eq` macros are no longer exported. +## Fixed +- Bindgen no longer panics when parsing an objective-C header that includes a + Rust keyword that cannot be a raw identifier, such as: `self`, `crate`, + `super` or `Self`. + +# 0.67.0 + +This version was skipped due to some problems on the release workflow. + +# 0.66.1 + +## Removed +* Revert source order sorting (#2543) due to correctness regressions #2558. + +# 0.66.0 + +## Added + +* Added the `--generate-cstr` CLI flag to generate string constants as `&CStr` + instead of `&[u8]`. (Requires Rust 1.59 or higher.) +* Added the `--generate-shell-completions` CLI flag to generate completions for + different shells. +* The `--wrap-static-fns` option can now wrap `va_list` functions as variadic functions + with the experimental `ParseCallbacks::wrap_as_variadic_fn` method. +* Add target mappings for riscv32imc and riscv32imac. +* Add the `ParseCallbacks::field_visibility` method to modify field visibility. + +## Changed + +* Non-UTF-8 string constants are now generated as references (`&[u8; SIZE]`) + instead of arrays (`[u8; SIZE]`) to match UTF-8 strings. +* Wrappers for static functions that return `void` no longer contain a `return` + statement and only call the static function instead. +* The `--wrap-static-fns` option no longer emits wrappers for static variadic + functions. +* Depfiles generated with `--depfile` or `Builder::depfile` will now properly + generate module names and paths that include spaces by escaping them. To make + the escaping clear and consistent, backslashes are also escaped. +* Updated `bitflags` dependency to 2.2.1. This changes the API of `CodegenConfig`. +* Prettyplease formatting is gated by an optional, enabled by default Cargo + feature when depending on `bindgen` as a library. +* Items are now parsed in the order they appear in source files. This may result in + auto-generated `_bindgen_*` names having a different index. +* Use default visibility for padding fields: Previously, padding fields were + always public. Now, they follow the default visibility for the type they are + in. +* Compute visibility of bitfield unit based on actual field visibility: A + bitfield unit field and its related functions now have their visibility + determined based on the most private between the default visibility and the + actual visibility of the bitfields within the unit. + +## Removed +* Remove redundant Cargo features, which were all implicit: + - bindgen-cli: `env_logger` and `log` removed in favor of `logging` + - bindgen (lib): + + `log` removed in favor of `logging` + + `which` removed in favor of `which-logging` + + `annotate-snippets` removed in favor of `experimental` + +* Prettyplease is available as a `Formatter` variant now. + +# 0.65.1 + +## Fixed + +* The `Builder::rustfmt_bindings` method was added back and tagged as + deprecated instead of being removed. +* Broken documentation links were fixed. + +# 0.65.0 + +## Added + * Added the `Builder::default_visibility` method and the + `--default-visibility` flag to set the default visibility of fields. (#2338) + * Added the `--formatter` CLI flag with the values `none`, `rustfmt` and + `prettyplease` to select which tool will be used to format the bindings. The + default value is `rustfmt`. (#2453) + * Added the `Builder::formatter` method and the `Formatter` type to select + which tool will be used to format the bindings. (#2453) + * Added the `Builder::emit_diagnostics` method and the `--emit-diagnostics` + flag to enable emission of diagnostic messages under the `experimental` + feature. (#2436) + * Added support for the `"efiapi"` calling convention (#2490). + * Added the `ParseCallbacks::read_env_var` method which runs everytime + `bindgen` reads and environment variable. (#2400) + * Added the `ParseCallbacks::generated_link_name_override` method which allow + overriding the link name of items. (#2425) + * Add support for C `enum`s when generating code while using the + `--wrap-static-fns` feature. (#2415) + +## Changed + * Static functions with no arguments use `void` as their single argument + instead of having no arguments when the `--wrap-static-fns` flag is used. + (#2443) + * The source file generated when the `--wrap-static-fns` flag is enabled now + contains `#include` directives with all the input headers and all the source + code added with the `header_contents` method. (#2447) + * The source file generated when the `--wrap-static-fns` flag no longer uses + `asm` labeling and the link name of static wrapper functions is allowed to + be mangled. (#2448) + * The documentation of the generated `type` aliases now matches the comments + of their `typedef` counterparts instead of using the comments of the aliased + types. (#2463) + * The `Builder::rustfmt_bindings` methods and the `--no-rustfmt-bindings` flag + are now deprecated in favor of the formatter API. (#2453) + +## Removed + * The following deprecated flags were removed: `--use-msvc-mangling`, + `--rustfmt-bindings` and `--size_t-is-usize`. (#2408) + * The `Bindings::emit_warnings` and `Bindings::warnings` methods were removed + in favor of `--emit-diagnostics`. (#2436) + * Bindgen no longer generates C string constants that cannot be represented as + byte slices. (#2487) + +# 0.64.0 + +## Added + * Added a new set of flags `--with-derive-custom`, + `--with-derive-custom-struct`, `--with-derive-custom-enum` and + `--with-derive-custom-enum` to add custom derives from the CLI. + * Added the `--experimental` flag on `bindgen-cli` and the `experimental` + feature on `bindgen` to gate experimental features whose implementation is + incomplete or are prone to change in a non-backwards compatible manner. + * Added a new set of flags and their equivalent builder methods + `--wrap-static-fns`, `--wrap-static-fns-suffix` and `--wrap-static-fns-path` + to generate C function wrappers for `static` or `static inline` functions. + This feature is experimental. + +## Changed + * Fixed name collisions when having a C `enum` and a `typedef` with the same + name. + * The `ParseCallbacks::generated_name_override` method now receives `ItemInfo<'_>` as + argument instead of a `&str`. + * Updated the `clang-sys` crate version to 1.4.0 to support clang 15. + * The return type is now omitted in signatures of functions returning `void`. + * Updated the `clap` dependency for `bindgen-cli` to 4. + * Rewrote the `bindgen-cli` argument parser which could introduce unexpected + behavior changes. + * The `ParseCallbacks::add_derives` method now receives `DeriveInfo<'_>` as + argument instead of a `&str`. This type also includes the kind of target type. + +# 0.63.0 + +## Added + * new feature: `process_comments` method to the `ParseCallbacks` trait to + handle source code comments. + +## Changed + * Only wrap unsafe operations in unsafe blocks if the `--wrap_unsafe_ops` + option is enabled. + * Replace the `name: &str` argument for `ParseCallbacks::add_derives` by + `info: DeriveInfo`. + * All the rust targets equal or lower than `1.30` are being deprecated and + will be removed in the future. If you have a good reason to use any of these + targets, please report it in the issue tracker. + +## Removed + + * The following deprecated methods and their equivalent CLI arguments were + removed: `whitelist_recursively`, `hide_type`, `blacklist_type`, + `blacklist_function`, `blacklist_item`, `whitelisted_type`, + `whitelist_type`, `whitelist_function`, `whitelisted_function`, + `whitelist_var`, `whitelisted_var`, `unstable_rust`. + +# 0.62.0 + +## Added + + * new feature: `--override-abi` flag to override the ABI used by functions + matching a regular expression. + * new feature: allow using the `C-unwind` ABI in `--override-abi` on nightly + rust. + +## Changed + + * Regex inputs are sanitized so alternation (`a|b`) is handled correctly but + wildcard patterns (`*`) are now considered invalid. The `.*` pattern can be + used as a replacement. + * the `ParseCallbacks`trait does not require to implement `UnwindSafe`. + * the `Builder::parse_callbacks` method no longer overwrites previously added + callbacks and composes them in a last-to-first manner. + * any generated rust code containing unsafe operations inside unsafe functions + is wrapped in unsafe blocks now. + +## Fixed + + * Various issues with upcoming clang/libclang versions have been fixed. + +# 0.61.0 + +Released 2022/10/16 + +## Added + + * new feature: `--sort-semantically` flag to sort the output in a predefined + manner [(#1743)]. + * new feature: `Bindgen::emit_warnings` method to emit warnings to stderr in + build scripts. + * new feature: `--newtype-global-enum` flag to generate enum variants as + global constants. + * new feature: `--default-non-copy-union-style` flag to set the default style + of code used to generate unions with non-`Copy` members. + * new feature: `--bindgen-wrapper-union` flag to mark any union that matches a + regex and has a non-Copy member to use a bindgen-generated wrapper for its + fields. + * new feature: `--manually-drop-union` flag to mark any union that matches a + regex and has a non-`Copy` member to use `ManuallyDrop`. + * new feature: `--merge-extern-blocks` flag to merge several `extern` blocks + that have the same ABI. + * new feature: `--no-size_t-is-usize` flag to not bind `size_t` as `usize`. + * new feature: `Builder` implements `Clone`. + +## Changed + + * clap and regex have been updated, new msrv is 1.57. + * The `--enable-function-attribute-detection` flag is also used to detect + diverging functions so the generated bindings use `!` as the return type. + * The `--size_t-is-usize` flag is enabled by default. + * Unused type aliases for `` types are no longer emitted. + * The `blocklist` options now can be used to block objective-C methods. + * The `core::ffi` module is used the sized raw integer types + instead of `std::os::raw` if the Rust target version is `1.64` or higher and + the `--use-core` flag is enabled. + * The `bindgen` CLI utility must be installed using `cargo install + bindgen-cli` now. + * Using `bindgen` as a library no longer pulls clap and any other CLI + related dependencies. + +## Fixed + + * Const correctness of incomplete arrays has been fixed. (#2301) + * C++ inline namespaces don't panic. (#2294) + +[(#1743)]: https://github.com/rust-lang/rust-bindgen/issues/1743 + +# 0.60.1 + +Released 2022/06/06 + +## Fixed + + * Fixed stack overflow in generated tests for structs with many fields (#2219). + +# 0.60.0 + +Released 2022/06/05 + +## Added + + * Objective-C structs now derive `Debug` and `Copy` to support C and Objective-C structs. [(#2176)][] + * Allow fully-qualified derives. (#2156) + * Bindings generation now returns a more suitable error (#2125) + * `--version --verbose` now prints clang version (#2140). + * Experimental vtable generation (#2145). + * Added an `--allowlist-file` option (#2122). + * Support for vectorcall ABI (#2177). + +## Fixed + + * Fixed lifetimes with Objective-C trait templates. [(#2176)][] + * Fixed objc imports for non-`#[macro_use]` use. [(#2176)][] + * Handle differences between clang and rustc targets for RISCV (#2137). + * `BINDGEN_EXTRA_CLANG_ARGS` is respected on the CLI now (#1723). + * Use common type alias for anonymous enums in consts mode (#2191) + * Look for `#[must_use]` in typedefs (#2206). + * Fixed derive on packed structs (#2083). + * Fixed warnings on layout tests (#2203). + +## Changed + + * cexpr, clap, and nom have been updated, new msrv is 1.54. + +## Removed + + * Support for ancient libclang versions has been removed. + + [(#2176)]: https://github.com/rust-lang/rust-bindgen/pull/2176 + +# 0.59.2 + +Released 2021/11/26 + + * cexpr+env_logger bump. + * Various fixes for C++ crashes / hangs. + * Enums now respect annotations and derives properly in more cases. + * Some more APIs (blocklist-file, etc). + * 'static lifetime is elided when appropriate. + +# 0.59.1 + +Released 2021/07/26 + +## Fixed + + * Fixed incorrect bitfield constructors generated for very large bitfields (#2082). + +# 0.59.0 + +Released 2021/07/20 + +## Added + + * Support emitting Makefile-syntax depfiles (#2026) + * Add a C naming option (#2045) + * Allow explicit padding (#2060) + * Add custom derives callback (#2059) + * Let Rust derive everything but Default for large arrays in 1.47 and later (#2070). + +## Fixed + + * Constants now have docstrings (#2027) + * Don't generate bindings for deleted member functions. (#2044) + * Zero out padding in custom Default trait implementations (#2051) + * Identify forward declarations in params. (#2052) + * Add env var EXTRA_CLANG_ARGS_. (#2031) + +## Changed + + * cexpr and nom have been updated, new msrv is 1.44 (#2073). + +# 0.58.1 + +Released 2021/04/06 + +## Added + + * Re-introduced unintentionally removed + `bindgen::Builder::whitelist_recursively` (deprecated in favor of + `bindgen::Builder::allowlist_recursively`). [#2022][] + +# 0.58.0 + +Released 2021/04/03 + +## Added + + * Add option to translate enum integer types to native Rust integer types. + [#2004][] + * Add callback to check derives for blocklisted types. [#2007][] + * Add a flag to ensure all symbols are resolved when a library is loaded. + [#2013][] + * Add from_library for generated dynamic library structs [#2011][]. + +## Fixed + + * Track union layout more accurately. Fixes [an AArch64 bug] and [makes the + bindings more portable] where unions could return garbage data ([#1984]) + * Use original name when checking allowlist for anonymous enum variants. [#2006][] + +## Changed + +## Deprecated + +* `bindgen::Builder::whitelist_type` is deprecated in favor of + `bindgen::Builder::allowlist_type`. [#1812][] + +* `bindgen::Builder::whitelist_function` is deprecated in favor of + `bindgen::Builder::allowlist_function`. [#1812][] + +* `bindgen::Builder::whitelist_var` is deprecated in favor of + `bindgen::Builder::allowlist_var`. [#1812][] + +* `--whitelist-type` is deprecated in favor of + `--allowlist-type`. [#1812][] + +* `--whitelist-function` is deprecated in favor of + `--allowlist-function`. [#1812][] + +* `--whitelist-var` is deprecated in favor of + `--allowlist-var`. [#1812][] + +* `bindgen::Builder::blacklist_type` is deprecated in favor of + `bindgen::Builder::blocklist_type`. [#1812][] + +* `bindgen::Builder::blacklist_function` is deprecated in favor of + `bindgen::Builder::blocklist_function`. [#1812][] + +* `bindgen::Builder::blacklist_item` is deprecated in favor of + `bindgen::Builder::blocklist_item`. [#1812][] + +* `--blacklist-type` is deprecated in favor of + `--blocklist-type`. [#1812][] + +* `--blacklist-function` is deprecated in favor of + `--blocklist-function`. [#1812][] + +* `--blacklist-item` is deprecated in favor of + `--blocklist-item`. [#1812][] + +[#1984]: https://github.com/rust-lang/rust-bindgen/pull/1984 +[an AArch64 bug]: https://github.com/rust-lang/rust-bindgen/issues/1973 +[makes the bindings more portable]: https://github.com/rust-lang/rust-bindgen/issues/1983 + +## Removed + +## Fixed + +## Security + +--- + +# 0.57.0 + +Released 2021/02/01 + +## Added + +* Expose module-raw-lines to the CLI (#1936) +* Added an option to fit macro constants to smaller types (#1945) +* Add an option to respect C++ access specifiers on fields (#1968) + +## Fixed + +* Improved C++ auto-detection (#1933) +* Fixed layout of bitfields in some edge cases (#1950) +* Escape the dyn keyword properly (#1951) +* Use absolute paths for unsaved files passed to clang (#1857). + +# 0.56.0 + +Released 2020/11/26 + +## Added + +* Objective-c bindings generate `From for ParentClass` as well as `TryFrom for ChildClass` ([#1883][]). +* Experimental dynamic library support via `dynamic_library_name` (#1846). +* Option to disable deriving `Default` on a per-struct basis (#1930). + +## Changed + +* Objective-c bindings borrow self rather than take ownership ([#1883][]). +* Templates and enums now correctly use the same naming scheme as other types + (#1891). + +## Fixed + +* Constructors in wasm32 now return a value. (#1877). +* Fixed objective-c protocol impl blocks for parent classes's protocols ([#1883][]). + +[#1883]: https://github.com/rust-lang/rust-bindgen/issues/1883 + +-------------------------------------------------------------------------------- + +# 0.55.1 + +Released 2020/08/24. + +## Fixed + + * Fixed a regression where anonymous enums referenced by members or such won't + generate valid Rust code. (#1882). + +-------------------------------------------------------------------------------- + +# 0.55.0 + +Released 2020/08/23. + +## Removed + + * Support for libclang 3.8 has been removed (#1830). + +## Added + + * Added options to avoid deriving the Debug trait (#1858). + + * Added options to allow to override the default anonymous field prefix (#1859). + + * Added options to allow to override the default macro integer type from the + command line (#1863). + +## Changed + + * Typed anonymous enums now generate better code (#1850). + + * Objective-C bindings are more idiomatic now (#1847). + + * Updated to clang-sys 1.0. Minimum supported rust version is 1.40 as + a consequence of that change. + +## Fixed + + * Fixed constness of multi-dimensional arrays in some cases (#1861). + + * Fixed wrong target given to clang when compiling with a target which doesn't + match the target clang expects (#1870, #1878). + + * Fixed wrong flags being computed for cross-compilation cases where the target + wasn't explicitly provided via clang flags (#1872). + +Thanks again to all the awesome contributors that sent patches included in this +release! + +-------------------------------------------------------------------------------- + +# 0.54.1 + +Released 2020/07/06. + +**Yanked**: The change in #1798 is technically breaking, see PR for details. + +## Added + + * Added ParseCallbacks::func_macro to be able to process function-like macros. + (#1792). + + * Allowed IntKind::Custom to represent paths instead of idents (#1800). + +## Changed + + * Generated comment now includes the bindgen version, and can be disabled + (#1814). + + * Various documentation improvements. + +## Fixed + + * Typedefs for types with the same names as rust primitive types compiles + (#1798). + + * Bindgen dependencies will now get rebuilt when various environment variables + that affect bindgen change (#1809, #1813). + + * Various fixes to command_line_flags (#1816, #1819, #1821). + + * Functions that start with `operator` now get properly generated (#1817). + + +Thanks to all the awesome contributors that sent patches included in this +release! + +-------------------------------------------------------------------------------- + +# 0.54.0 + +Released 2020/05/21. + +## Added + + * New command line flag to allow disabling untagged unions (#1789). + +## Changed + + * Various documentation improvements (#1764, #1751, #1757). + * Better Objective-C support (#1722, #1750). + +## Fixed + + * Rust method wrappers are not emitted for blacklisted functions (#1775). + * Fixed function signatures in some edge cases involving Objective-C or + `__stdcall` (#1781). + +-------------------------------------------------------------------------------- + +# 0.53.3 + +Released 2020/05/21. + +*Note: This release contains the same fixes and additions as 0.54.0, but without +the Objective-C breaking changes* + +## Added + + * New command line flag to allow disabling untagged unions (#1789). + +## Fixed + + * Rust method wrappers are not emitted for blacklisted functions (#1775). + * Fixed function signatures in some edge cases involving Objective-C or + `__stdcall` (#1781). + +-------------------------------------------------------------------------------- + +# 0.53.2 + +Released 2020/03/10. + +## Changed + + * clang-sys and cexpr have been updated (#1741 and #1744). + * Runtime of some commands has been improved (#1737) + * Some error messages have been improved (#1734). + +-------------------------------------------------------------------------------- + +# 0.53.1 + +Released 2020/02/03. + +## Added + + * Opt-in to convert size_t to usize again (#1720). + +-------------------------------------------------------------------------------- + +# 0.53.0 + +Released 2020/02/02. + +## Added + + * Support for wasm_import_module. (#1691). + * non_exhaustive feature is now stable (#1698). + * Various objective-C improvements (#1702). + +## Changed + + * Removed size_t to usize conversion rule (#1688). + +## Fixed + + * Various unneeded padding fields shouldn't be generated anymore (#1710). + * Bitfields on packed structs should generate correct layout (#1717). + * Too large bitfield blocks now generate compiling code (#1719). + +-------------------------------------------------------------------------------- + +# 0.52.0 + +Released 2019/11/19. + +## Added + + * Added `newtype` enum style, much like `bitfield` but without the bitwise ops + (#1677). + * Added support for `MaybeUninit` rather than `mem::uninitialized()` (#1666). + * Allowed static linking (#1620) behind a feature. Note that **if you're using + `default-features = false`, you probably want to use the `"runtime"` feature + to get the same behavior as before**. + +## Changed + + * Use c_void from core when --use-core is specified and available (#1634). + * Various dependencies and features are non-default now (like `regex` unicode + features). + +## Fixed + + * Fixed crash when unknown keywords are used before a namespace (#1678). + * Do not generate implementation for clone for flexible array members (#1664). + * Fixed `#[must_use]` support for libclang 9+ (#1646). + * Fixed `BitfieldUnit` constructor to handle 64 bit wide bitfields on 32 bit (#1640). + * Added a `ParseCallbacks` handler for included files. (#1637). + +# 0.51.1 + +Released 2019/09/23. + +## Fixed + + * Mismatched `Ord` and `PartialOrd` implementations were fixed, which regresses + bindgen in funny ways when using rustc nightly. Dot releases for a few of the + previous versions of bindgen will be created with this fix. Also, + a `v0.51.1-oldsyn` version was uploaded without the syn update. [#1627][] + +## Changed + + * Syn and related dependencies have been updated. [#1611][] + + * Switches added to allow less dependencies. In + particular: It won't pull `failure` and related dependencies by default, and + there's a default-on `which-rustfmt` feature which allows to get rid of + `which` altogether. [#1615][] / [#1625][] + + * `fxhash` dependency was switched to `rustc-hash`. [#1626][] + +[#1627]: https://github.com/rust-lang/rust-bindgen/issues/1627 +[#1611]: https://github.com/rust-lang/rust-bindgen/issues/1611 +[#1615]: https://github.com/rust-lang/rust-bindgen/issues/1615 +[#1625]: https://github.com/rust-lang/rust-bindgen/issues/1625 +[#1626]: https://github.com/rust-lang/rust-bindgen/issues/1626 +[#1627]: https://github.com/rust-lang/rust-bindgen/issues/1627 + +# 0.51.0 + +Released 2019/07/26. + +## Fixed + + * Improve workaround for LLVM stack overflow when evaluating value-dependent + expressions. [#1591][] + + * Bindgen will properly detect the layout of incomplete arrays. [#1592][] + + * Bindgen will properly detect the layout of empty unions and forward + declarations of unions. [#1593][] and [#1595][]. Thanks @pmarks! + +## Changed + + * Refactored the way layout of `wchar_t` is computed. This is a breaking change + since `IntKind::WChar` (exposed in `ParseCallbacks`) no longer needs a `size` + member. [#1596][] + +## Added + + * Bindgen now reads `RUSTFMT` in the environment to try to find a suitable + `rustfmt` binary. [#1602][] + +[#1591]: https://github.com/rust-lang/rust-bindgen/issues/1591 +[#1592]: https://github.com/rust-lang/rust-bindgen/issues/1592 +[#1593]: https://github.com/rust-lang/rust-bindgen/issues/1593 +[#1595]: https://github.com/rust-lang/rust-bindgen/issues/1595 +[#1596]: https://github.com/rust-lang/rust-bindgen/issues/1596 +[#1602]: https://github.com/rust-lang/rust-bindgen/issues/1602 + +# 0.50.0 + +Released 2019/07/01. + +## Added + +* Fixed pointers to Objective C blocks [#1582][]. + +* Various bindgen auto-generated types are now constructible in `const fn` + contexts [#1571][] + +* It is possible to generate `#[non_exhaustive]` enums for rust nightly targets. + [#1575][] + +* It is possible to avoid building clap now if you're using bindgen as + a library. [#1581][]. + +[#1571]: https://github.com/rust-lang/rust-bindgen/issues/1571 +[#1575]: https://github.com/rust-lang/rust-bindgen/issues/1575 +[#1581]: https://github.com/rust-lang/rust-bindgen/issues/1581 +[#1582]: https://github.com/rust-lang/rust-bindgen/issues/1582 + +# 0.49.3 + +Released 2019/06/25. **YANKED** + +## Added + +* Various bindgen auto-generated types are now constructible in `const fn` + contexts [#1571][] + +* It is possible to generate `#[non_exhaustive]` enums for rust nightly targets. + [#1575][] + +* It is possible to avoid building clap now if you're using bindgen as + a library. [#1581][]. + +[#1571]: https://github.com/rust-lang/rust-bindgen/issues/1571 +[#1575]: https://github.com/rust-lang/rust-bindgen/issues/1575 +[#1581]: https://github.com/rust-lang/rust-bindgen/issues/1581 + +# 0.49.2 + +Released 2019/05/22 + +## Changed + +* Bindgen now has an option to generate array arguments as pointer to the array, + not to the element (so `void foo(int arr[2])` would be generated as + `arr: *mut [c_int; 2]` rather than `arr: *mut c_int`. Thanks @elichai! + [#1564][]. + +[#1564]: https://github.com/rust-lang/rust-bindgen/issues/1564 + +# 0.49.1 + +Released 2019/05/16 + +## Fixed + +* Bindgen will not emit `#[link_name]` attributes in win32 and macos for + C functions and constants where it can detect it's not needed (thanks + @michaelwoerister!). [#1558][] + +## Changed + +* Bindgen will no longer use `hashbrown` internally, and will use fxhash + and `std::HashMap`. This is equivalent for newer `rustc`s since `hashbrown` + was merged in libstd, and the performance difference should be close to zero + for older rustcs. + +[#1558]: https://github.com/rust-lang/rust-bindgen/issues/1558 + +# 0.49.0 + +Released 2019/03/27 + +## Added + +* BINDGEN_EXTRA_CLANG_ARGS environment variable was added (thanks @jhwgh1968!). [#1537][] + +## Fixed + +* Bindgen will properly name parameters inside nested function pointer + declarations (thanks @flowbish!). [#1535][] + +## Changed + +* Derive code was greatly improved by @jethrogb. [#1540][] +* Derive analysis now handles trivial types more gracefully. [#1492][] +* clang-sys was updated by @eclipseo. [#1539][] +* bindgen should now get include paths correctly even when `--target` is + specified. The `detect_include_paths` option can be used to opt-out of this + behavior. + +[#1535]: https://github.com/rust-lang/rust-bindgen/issues/1535 +[#1537]: https://github.com/rust-lang/rust-bindgen/issues/1537 +[#1540]: https://github.com/rust-lang/rust-bindgen/issues/1540 +[#1492]: https://github.com/rust-lang/rust-bindgen/issues/1492 + +# 0.48.1 + +Released 2019/03/06 + +## Fixed + +* Bindgen will properly lay out types that use reference members. [#1531][] + +[#1531]: https://github.com/rust-lang/rust-bindgen/issues/1531 + +-------------------------------------------------------------------------------- + +# 0.48.0 + +Released 2019/03/04 + +## Changed + +* Default rust target was changed to 1.33, which means that bindgen can get much + more often the layout of structs right. [#1529][] + +## Fixed + +* Bindgen will output repr(align) just when needed for unions. [#1498][] + +[#1529]: https://github.com/rust-lang/rust-bindgen/issues/1529 +[#1498]: https://github.com/rust-lang/rust-bindgen/issues/1498 + +-------------------------------------------------------------------------------- + +# 0.47.4 + +Released 2020/11/13 + +## Added + +* Backported BINDGEN_EXTRA_CLANG_ARGS support per request (#1910). + +-------------------------------------------------------------------------------- + +# 0.47.3 + +Released 2019/02/25 + +## Changed + +* Allowed to build with which 1.0. + +-------------------------------------------------------------------------------- + +# 0.47.2 + +Released 2019/02/22 + +## Fixed + +* @flowbish fixed code generation for nested function prototypes. [#1508][] +* Some complex C++ constructs no longer panic on code generation [#1513][] +* Implicit template parameters are now appended to base classes [#1515][] +* @flier fixed single-argument block pointers [#1519][] +* Bindgen won't panic when parsing an undeduced auto type [#1525][] + +[#1508]: https://github.com/rust-lang/rust-bindgen/issues/1508 +[#1513]: https://github.com/rust-lang/rust-bindgen/issues/1513 +[#1515]: https://github.com/rust-lang/rust-bindgen/issues/1515 +[#1519]: https://github.com/rust-lang/rust-bindgen/issues/1519 +[#1525]: https://github.com/rust-lang/rust-bindgen/issues/1525 + +-------------------------------------------------------------------------------- + +# 0.47.1 + +Released 2019/02/02 + +## Changed + +* @luser improved the error message when rustfmt cannot be found [#1501][] + +## Fixed + +* Reverted `clang-sys` update for regressions [#1505][] + +[#1505]: https://github.com/rust-lang/rust-bindgen/issues/1505 +[#1501]: https://github.com/rust-lang/rust-bindgen/issues/1501 + +-------------------------------------------------------------------------------- + +# 0.47.0 + +Released 2019/01/19 + +## Changed + +- `#pragma pack(n)` is now translated to `#[repr(C, packed(n))]` when targeting Rust 1.33+. [#537][] + +[#537]: https://github.com/rust-lang/rust-bindgen/issues/537 + +* Bitfield enums now use `#[repr(transparent)]` instead of `#[repr(C)]` when targeting Rust 1.28+. [#1474][] + +[#1474]: https://github.com/rust-lang/rust-bindgen/issues/1474 + +## Fixed + +* `#[repr(packed)]` is now properly added if the struct only contains a vtable. + [#1495][] + +[#1495]: https://github.com/rust-lang/rust-bindgen/pull/1495 + +* `clang-sys` should now more accurately find libclang versions when multiple + of them are available. [#1489][] + +[#1489]: https://github.com/rust-lang/rust-bindgen/pull/1489 + +-------------------------------------------------------------------------------- + +# 0.33.1 .. 0.46.0 + +https://github.com/rust-lang/rust-bindgen/compare/v0.32.2...v0.46.0 + +(Just a sneak peek, since a lot of stuff has changed :D) + +## Added + +* APIs to add lines to specific rust modules / C++ namespaces exist now. + [#1307][] + +[#1307]: https://github.com/rust-lang/rust-bindgen/issues/1307 + +## Removed + +* The link options (`link`, `link_framework`, `link_static`) have been removed. + They did nothing already, see [#104][] + +[#104]: https://github.com/rust-lang/rust-bindgen/issues/104 + +## Changed + +* Associated constants are used now for bitfield enums when available. [#1166][] + +[#1166]: https://github.com/rust-lang/rust-bindgen/issues/1166 + +* New versions of a bunch of dependencies (syn / quote / etc.). + +## Fixed + +* Better target information from clang to properly generate types when + cross-compiling [#1289][]. + +[#1289]: https://github.com/rust-lang/rust-bindgen/issues/1289 + +* Pointer constness was fixed in a bunch of cases when using `int const*` and + such. [#1311][] [#1312][]. + +[#1311]: https://github.com/rust-lang/rust-bindgen/issues/1311 +[#1312]: https://github.com/rust-lang/rust-bindgen/issues/1312 + +* Bitfields now work properly on big-endian machines. [#1340][] + +[#1340]: https://github.com/rust-lang/rust-bindgen/issues/1340 + +* `wchar_t` layout works properly now. [#1345][] + +[#1345]: https://github.com/rust-lang/rust-bindgen/issues/1345 + +* Functions can be blacklisted now. [#1364][] + +[#1364]: https://github.com/rust-lang/rust-bindgen/issues/1364 + +* ... Lot's more! + +-------------------------------------------------------------------------------- + +# 0.33.1 + +Released 2018/02/14 + +## Fixed + +* Reverted the dependency update to `quote = "0.4"` and addition of the + `proc_macro2` dependency. The `proc_macro2` crate depends on `rustc` internal + libraries, which means that CLIs which use it must be run under `rustup`, + which is not acceptable for `bindgen`. [#1248][] + +[#1248]: https://github.com/rust-lang/rust-bindgen/issues/1248 + +-------------------------------------------------------------------------------- + +# 0.33.0 + +-------------------------------------------------------------------------------- + +# 0.32.2 + +Released 2018/01/22 + +## Fixed + +* Avoid symbol generation for pure virtual functions. [#1197][] +* Handling of `_Complex _Float128`. [#1087][] +* Regression on code generation for variadic functions. [#1216][] +* Enum code generation generates conflicting repr hint warning. [#1224][] +* Constified code generation for enums with an explicit type of `bool`. [#1145][] +* Bindgen will now call `rustfmt` directly instead of via `rustup`. [#1184][] + +[#1197]: https://github.com/rust-lang/rust-bindgen/issues/1197 +[#1087]: https://github.com/rust-lang/rust-bindgen/issues/1087 +[#1216]: https://github.com/rust-lang/rust-bindgen/issues/1216 +[#1224]: https://github.com/rust-lang/rust-bindgen/issues/1224 +[#1145]: https://github.com/rust-lang/rust-bindgen/issues/1145 +[#1184]: https://github.com/rust-lang/rust-bindgen/issues/1184 + +# 0.32.1 + +Released 2017/12/18 + +## Fixed + +* When translating C/C++ `enum`s into Rust `enum`s using `rustified_enum` / + `--rustified-enum`, properly add `#[repr(C)]` to the emitted `enum`. [#1183][] + +[#1183]: https://github.com/rust-lang/rust-bindgen/issues/1183 + +-------------------------------------------------------------------------------- + +# 0.32.0 + +Released 2017/12/08 + +## Added + +* Added support for bit-field allocation units that are larger than 64 bits + wide. Note that individual bit-fields within such units are still restricted + to being no wider than 64 bits. [#1158][] + +* We can now generate random C header files and test that `bindgen` can process + them with the `quickcheck` crate. Initial support landed in [#1159][] with a + few more additions in follow up pull requests. + +## Changed + +* The `bindgen::Builder::{constified_enum_module,{bitfield,rustified}_enum}` + builder methods and their corresponding CLI flags now compare their argument + to the C/C++ `enum`'s "canonical path", which includes leading namespaces, + rather than its "canonical name", which does not. This is a breaking change + that requires callers which target a namespaced C++ enum to call e.g. + `bitfield_enum("::")` rather than e.g. + `bitfield_enum("")`. [#1162][] + +* When a struct is packed to a smaller alignment that is still greater than one, + `bindgen` cannot emit Rust bindings that match the input source. Before, it + would emit `#[repr(packed)]` anyways, which packs to an alignment of one, but + this can lead to misalignment and UB. Now, `bindgen` will detect these + situations and convert the struct into an opaque blob of bytes with the proper + alignment. We are eagerly awaiting support for `#[repr(packed(N))]` in + Rust. [#1136][] + +## Fixed + +* There was a perfect storm of conditions that could cause `bindgen` not to emit + any bindings if spawning `rustfmt` to format the bindings failed. This is now + fixed. [#1112][] + +* In some circumstances, `bindgen` would emit type parameters twice for + references to template instantiations. This is now fixed. [#1113][] + +* When a C/C++ struct had a field named with a Rust keyword, and `impl_debug` + was enabled, the generated `impl Debug for ...` blocks could reference the + field by the Rust keyword name, rather than the non-keyword field name we + actually end up generating. This is now fixed. [#1123][] + +* There was a regression in 0.31.0 where C++ template aliases to opaque types + would sometimes not treat the aliased type as opaque. This is now + fixed. [#1118][] + +* There was a regression in 0.31.0 that could cause `bindgen` to panic when + parsing nested template classes. This is now fixed. [#1127][] + +* Unnamed bit-fields do not affect alignment of their struct or class in C/C++, + however `bindgen` interpreted them as doing so, which could generate + `#[repr(C)]` structs expecting to have an incorrect alignment. This is now + fixed. [#1076][] + +* When a zero-sized type was used in a bit-field, `bindgen` could + divide-by-zero. This is now fixed. [#1137][] + +* When a template parameter is used in a bit-field, `bindgen` would panic. This + is now fixed. [#1140][] + +* There was a regression in 0.31.0 where if `bindgen` was given a header file + that did not exist, it would panic. This is now fixed, and it will instead + properly report the error. [#1146][] + +* In some cases, generated bit-field getters and setters could access memory + beyond `self`. This is now fixed. [#954][] + +[#1162]: https://github.com/rust-lang/rust-bindgen/issues/1162 +[#1113]: https://github.com/rust-lang/rust-bindgen/issues/1113 +[#1112]: https://github.com/rust-lang/rust-bindgen/issues/1112 +[#1123]: https://github.com/rust-lang/rust-bindgen/issues/1123 +[#1127]: https://github.com/rust-lang/rust-bindgen/issues/1127 +[#1136]: https://github.com/rust-lang/rust-bindgen/issues/1136 +[#1137]: https://github.com/rust-lang/rust-bindgen/issues/1137 +[#1140]: https://github.com/rust-lang/rust-bindgen/issues/1140 +[#1146]: https://github.com/rust-lang/rust-bindgen/issues/1146 +[#1118]: https://github.com/rust-lang/rust-bindgen/issues/1118 +[#1076]: https://github.com/rust-lang/rust-bindgen/issues/1076 +[#1158]: https://github.com/rust-lang/rust-bindgen/issues/1158 + +-------------------------------------------------------------------------------- + +# 0.31.0 + +Released 2017/10/27 + +## Added + +* 🎉 **A new `bindgen` reviewer: [@pepyakin](https://github.com/pepyakin)** 🎉 + You can ask @pepyakin to review all your future pull requests with `r? + @pepyakin` from now on 😄 + +* Timers for seeing which phases `bindgen` is spending its time in. On the + command line, use the `--time-phases` flag. From a builder, use the + `bindgen::Builder::time_phases(true)` method. [#938][] + +* You can now disable `#[derive(Copy)]` for all types with `--no-derive-copy` + and `bindgen::Builder::derive_copy(false)`. [#948][] + +* We now have an overview of `bindgen`'s code base and architecture for + newcomers in `CONTRIBUTING.md`. [#988][] + +* Derive `PartialOrd` with the `--with-derive-partialord` CLI flag or + `bindgen::Builder::derive_partialord(true)` builder method. [#882][] + +* Derive `Ord` with the `--with-derive-ord` CLI flag or + `bindgen::Builder::derive_ord(true)` builder method. [#884][] + +* When `PartialEq` cannot be derived because of an array larger than Rust's + array-derive limit, `bindgen` can emit an `impl PartialEq for ...` + block. Enable this behavior with the `--impl-partialeq` CLI flag or the + `bindgen::Builder::impl_partialeq(true)` method. [#1012][] + +* When deriving `PartialEq` for all types, you can now specify particular types + that shouldn't `derive(PartialEq)` with the `--no-partialeq ` CLI flag + or `bindgen::Builder::no_partialeq("")` builder method. [#996][] + +* Specify types that should not derive `Copy` with the `--no-copy ` CLI + flag or `bindgen::Builder::no_copy("")` builder method. This + functionality was previously only available via comment annotations in the + header sources. [#1099][] + +* When deriving `Hash` for all types, you can now specify particular types that + shouldn't `derive(Hash)` with the `--no-hash ` CLI flag or + `bindgen::Builder::no_hash("")` builder method. [#1105][] + +* The `bindgen` users guide now has an [FAQ section][faq]! If you have any FAQ + suggestions to put up there, please open a pull request. [#1020][] + +* Added `csmith` fuzzing infrastructure. `csmith` generates random C and C++ + programs, we feed those into `bindgen` as headers to generate bindings to, + then test that the generated bindings compile and that their layout tests + pass. This infrastructure landed in + [many small bits](https://github.com/rust-lang/rust-bindgen/issues?utf8=%E2%9C%93&q=label%3AA-csmith%20is%3Aclosed). + + We <3 folks who [help us find and fix issues via fuzzing][fuzzing]! *hint + hint* + +* Added experimental support for the `thiscall` ABI when targeting Rust + nightly. [#1065][] + +## Changed + +* If the user does not explicitly pass a `--target` argument for `libclang`, + `bindgen` will insert such an argument itself. See [#942][], [#947][], and + [#953][] for details. + +* C/C++ `enum`s are now translated into constants by default, rather than Rust + `enum`s. The old behavior was a big footgun because `rustc` assumes that the + only values of an `enum` are its variants, whereas a lot of C/C++ code uses + random values as `enum`s. Put these two things and it leads to *undefined + behavior*. Translating C/C++ `enum`s into Rust `enum`s is still available with + the `--rustified-enum ` CLI flag and + `bindgen::Builder::rustified_enum("")` builder method. [#758][] + +* Generated bindings are now pretty printed with `rustfmt` by default. + Previously, this option existed, but was off by default because `syntex` did + an OK job at pretty printing the bindings. Now that we are using `quote! { + ... }` instead of `syntex`, we lost that pretty printing, and now rely on + `rustfmt`. You can disable `rustfmt`ing with `--no-rustfmt-bindings` or + `bindgen::Builder::rustfmt_bindings(false)`. See [#925][] and [#1022][] for + details. + +## Deprecated + +* `bindgen::Builder::hide_type` is deprecated in favor of + `bindgen::Builder::blacklist_type`. [#987][] + +* `bindgen::Builder::whitelisted_type` is deprecated in favor of + `bindgen::Builder::whitelist_type`. [#987][] + +* `bindgen::Builder::whitelisted_function` is deprecated in favor of + `bindgen::Builder::whitelist_function`. [#985][] + +* `bindgen::Builder::whitelisted_var` is deprecated in favor of + `bindgen::Builder::whitelist_var`. [#989][] + +## Removed + +* Removed the dependency on (unmaintained) `syntex`, and **build times are cut + in half**! + + Before: + + ``` + $ cargo clean; cargo build + + Finished dev [unoptimized + debuginfo] target(s) in 98.75 secs + ``` + + After: + + ``` + $ cargo clean; cargo build + + Finished dev [unoptimized + debuginfo] target(s) in 46.26 secs + ``` + + [#925][] + +* The `BindgenOptions` type is no longer public. It had been deprecated in + previous releases. Use `bindgen::Builder` instead. [#1000][] + +## Fixed + +* Under certain conditions, a globally scoped `enum` could end up with bindings + in the wrong namespace module. [#888][] + +* Blacklisted types were incorrectly assumed to always be `Copy`able (and + assumed to implement other traits as well). `bindgen` is now conservatively + pessimistic about the traits that blacklisted types implement. [#944][] + +* When bitfields have a ridiculously large number of bits (for example, + `unsigned : 632;`) then `bindgen` was incorrectly deriving traits that + couldn't be derived, resulting in errors when compiling the bindings, and was + also generating `struct`s with an incorrect layout. Both issues have been + fixed. [#982][] + +* `_` is a valid identifier in some C++ contexts, but can't be referenced in + Rust, as it is the "throwaway identifier" (a term I just made up, if you use + it now, then you owe me money). `bindgen` will now translate `_` into `__` so + that it can be used on the Rust side. [#1008][] + +* Nested class definitions were sometimes being emitted in the wrong namespace + module in the generated bindings. [#1048][] + +* `bindgen` was mis-handling `union`s that contained bitfield members. This has + been fixed. [#744][] + +* Unsigned constants that were greater than `u32::MAX` were being mis-translated + by `bindgen`. This is now fixed. [#1040][] + +* When given a directory as an input file, or a file to which we don't have read + permissions, then `bindgen` will print a more useful error message + now. [#1029][] + +* `bindgen` previously attempted to derive `Hash` for structures with + flexibly-sized array members, but knowing how many elements exist in such + arrays requires program-specific knowledge that `bindgen` cannot + have. [#1094][] + +[faq]: https://rust-lang.github.io/rust-bindgen/faq.html +[fuzzing]: https://github.com/rust-lang/rust-bindgen/blob/main/csmith-fuzzing/README.md + +[#938]: https://github.com/rust-lang/rust-bindgen/issues/938 +[#888]: https://github.com/rust-lang/rust-bindgen/issues/888 +[#944]: https://github.com/rust-lang/rust-bindgen/issues/944 +[#942]: https://github.com/rust-lang/rust-bindgen/issues/942 +[#947]: https://github.com/rust-lang/rust-bindgen/issues/947 +[#953]: https://github.com/rust-lang/rust-bindgen/issues/953 +[#948]: https://github.com/rust-lang/rust-bindgen/issues/948 +[#925]: https://github.com/rust-lang/rust-bindgen/issues/925 +[#758]: https://github.com/rust-lang/rust-bindgen/issues/758 +[#988]: https://github.com/rust-lang/rust-bindgen/issues/988 +[#987]: https://github.com/rust-lang/rust-bindgen/issues/987 +[#985]: https://github.com/rust-lang/rust-bindgen/issues/985 +[#989]: https://github.com/rust-lang/rust-bindgen/issues/989 +[#1000]: https://github.com/rust-lang/rust-bindgen/issues/1000 +[#882]: https://github.com/rust-lang/rust-bindgen/issues/882 +[#884]: https://github.com/rust-lang/rust-bindgen/issues/884 +[#996]: https://github.com/rust-lang/rust-bindgen/issues/996 +[#982]: https://github.com/rust-lang/rust-bindgen/issues/982 +[#1008]: https://github.com/rust-lang/rust-bindgen/issues/1008 +[#1022]: https://github.com/rust-lang/rust-bindgen/issues/1022 +[#1048]: https://github.com/rust-lang/rust-bindgen/issues/1048 +[#1012]: https://github.com/rust-lang/rust-bindgen/issues/1012 +[#744]: https://github.com/rust-lang/rust-bindgen/issues/744 +[#1065]: https://github.com/rust-lang/rust-bindgen/issues/1065 +[#1040]: https://github.com/rust-lang/rust-bindgen/issues/1040 +[#1029]: https://github.com/rust-lang/rust-bindgen/issues/1029 +[#1094]: https://github.com/rust-lang/rust-bindgen/issues/1094 +[#1099]: https://github.com/rust-lang/rust-bindgen/issues/1099 +[#1105]: https://github.com/rust-lang/rust-bindgen/issues/1105 + +-------------------------------------------------------------------------------- + +# 0.30.0 + +Released 2017/08/28 + +## Added + +* Explicit control over choosing which Rust version (specific stable versions or + nightly Rust) to target. This defaults to the latest stable Rust + version. [#832][] + +```rust +bindgen::Builder::default() + .rust_target(bindgen::RustTarget::Stable_1_19) + // or `.rust_target(bindgen::RustTarget::Nightly)` to use unstable features +``` + +or + +``` +$ bindgen --rust-target 1.19 +# or `--rust-target nightly` to use unstable features +``` + +* Started adding `derive(Copy)` for large arrays of `Copy` things, even when the + array is too large to `derive(Clone)` because Rust doesn't implement `Clone` + for arrays of length greater than 32. [#874][] + +* `bindgen` can now determine which types are hashable and add `derive(Hash)` to + those types that support it. This is disabled by default, but can be enabled + via `bindgen::Builder::derive_hash` or `--with-derive-hash`. [#876][] + +* `bindgen` can now generate `impl Debug for Blah` trait implementations for + types that contain non-`Debug` types, and therefore cannot + `derive(Debug)`. This behavior can be enabled with + `bindgen::Builder::impl_debug` and `--impl-debug`. [#875][] + +* `bindgen` can now invoke `rustfmt` on the generated bindings. The bindings + have historically been fairly pretty printed, but sometimes this is not the + case, especially with the new `impl Debug for Blah` feature. Have `bindgen` + run `rustfmt` with `bindgen::Builder::rustfmt_bindings` and + `--rustfmt-bindings`, and use non-default `rustfmt` configuration files with + `bindgen::Builder::rustfmt_configuration_file` and + `--rustfmt-configuration-file`. [#900][] + +* `bindgen` can now determine which types can be compared with `==` and add + `derive(PartialEq)` to those types that support it. This is disabled by + default, but can be enabled via `bindgen::Builder::derive_partialeq` or + `--with-derive-partialeq`. [#878][] + +* Additionally, `bindgen` can also add `derive(Eq)` to those types which we + determined we could `derive(PartialEq)` and do not transitively contain any + floats. Enable this behavior with `bindgen::Builder::derive_eq` or + `--with-derive-eq`. [#880][] + +## Changed + +* Started emitting Rust `union`s when targeting stable Rust >= 1.19, not just + unstable nightly Rust. [#832][] + +* Emitted layout `#[test]`s no longer contain internal IDs for template + instantiations including pointers and arrays. This should make generated + bindings more stable across updates to unrelated parts of the input + headers. [#871][] + +* Determining whether a type can derive `Copy` or not was ported from an ad-hoc + algorithm to our fix-point framework. [#766][] + +* Determining whether a type has a destructor or not was also ported from an + ad-hoc algorithm to our fix-point framework. [#927][] + +## Deprecated + +* `bindgen::Builder::unstable_rust`/`--unstable-rust` is deprecated, in favor of + targeting explicit Rust versions with + `bindgen::Builder::rust_target`/`--rust-target` instead. [#832][] + +## Fixed + +* Fixed a regression in the `derive(Default)` analysis that resulted in some + opaque types deriving `Default` when they shouldn't have. [#889][] + +* Fixed a regression where template instantiation layout `#[test]`s were being + generated with invalid Rust identifiers. [#906][] + +[#832]: https://github.com/rust-lang/rust-bindgen/issues/832 +[#871]: https://github.com/rust-lang/rust-bindgen/issues/871 +[#874]: https://github.com/rust-lang/rust-bindgen/pull/874 +[#889]: https://github.com/rust-lang/rust-bindgen/pull/874 +[#766]: https://github.com/rust-lang/rust-bindgen/issues/766 +[#876]: https://github.com/rust-lang/rust-bindgen/issues/876 +[#875]: https://github.com/rust-lang/rust-bindgen/issues/875 +[#906]: https://github.com/rust-lang/rust-bindgen/pull/906 +[#900]: https://github.com/rust-lang/rust-bindgen/issues/900 +[#878]: https://github.com/rust-lang/rust-bindgen/issues/878 +[#880]: https://github.com/rust-lang/rust-bindgen/issues/880 +[#927]: https://github.com/rust-lang/rust-bindgen/issues/927 + +-------------------------------------------------------------------------------- + +# 0.29.0 + +Released 2017/07/31 + +## Added + +* ["Constified enum modules"](https://github.com/rust-lang/rust-bindgen/pull/741) + translating C/C++ `enum`s into constants within a module for namespacing, + rather than mangling the name of the generated constants. + + For example, it turns this: + + ```c++ + // bindgen-flags: --constified-enum-module PetKind + + enum PetKind { + Doggo, + Kitty, + Hamster + }; + + struct Pet { + PetKind kind; + char* noise; + }; + ``` + + Into this: + + ```rust + /* automatically generated by rust-bindgen */ + + pub mod PetKind { + pub type Type = ::std::os::raw::c_uint; + pub const Doggo: Type = 0; + pub const Kitty: Type = 1; + pub const Hamster: Type = 2; + } + #[repr(C)] + #[derive(Debug, Copy)] + pub struct Pet { + pub kind: PetKind::Type, + pub noise: *mut ::std::os::raw::c_char, + } + ``` + + The default translation strategy for `enum`s will generate constants with + names like `PetKind_Hamster` instead. + + Use `bindgen::Builder::constified_enum_module` or `--constified-enum-module`. + +* You can now + [mark particular template instantiations as "opaque"](https://github.com/rust-lang/rust-bindgen/pull/773), + so that `bindgen` emits a blob of bytes with the correct size and alignment + rather than creating generic Rust types. This is useful as a workaround for + when a template has a specialization for the given type arguments, which + `bindgen` does not yet support. Previously, it was all of a templates' + instantiations would be opaque or none of them would be. Use + `bindgen::Builder::opaque_type("SomeTemplate")` or `--opaque-type + "SomeTemplate"`. + +* Added the ability to + [preprocess and dump](https://github.com/rust-lang/rust-bindgen/pull/812) + the input headers given to `bindgen` to a file. This should make creating + reproducible, system independent, standalone test cases much easier! Bring on + the new issues! Use `bindgen::Builder::dump_preprocessed_input` or + `--dump-preprocessed-input`. + +* We now use a fix-point analysis to determine whether any given type can derive + `Debug`, or whether it has an explicit virtual table pointer. Previously we + were using an ad-hoc algorithm that had at various times suffered from things + like going into infinite loops when coming across cycles. Hopefully those + kinds of bugs are a thing of the past! + [#767](https://github.com/rust-lang/rust-bindgen/issues/767) + [#765](https://github.com/rust-lang/rust-bindgen/issues/765) + +## Changed + +* The `bindgen` repository has moved under the `rust-lang-nursery` umbrella! The + new repository URL is https://github.com/rust-lang-nursery/rust-bindgen 🎉 + +## Fixed + +* No longer generating layout tests for template instantiations using type + arguments that we didn't generate bindings for (which then caused compilation + errors). [#679](https://github.com/rust-lang/rust-bindgen/issues/769) + +* Fixed function name mangling when cross compiling bindings for + iOS. [#776](https://github.com/rust-lang/rust-bindgen/pull/776) + +* Don't include parent `inline namespace`s' names in types' names. Names of + types from some STLs were showing up like `std___cxx11_basic_string` when they + should have been + `std_basic_string`. [#789](https://github.com/rust-lang/rust-bindgen/issues/789) + +* Fixed a bug where we wouldn't generate type definitions for some types + referenced by an opaque type's methods, causing compilation + errors. [#807](https://github.com/rust-lang/rust-bindgen/issues/807) + +* Fixed function name mangling issues for win32 + targets. [#819](https://github.com/rust-lang/rust-bindgen/issues/819) + +* Fixed a bug where `bindgen` was generating a generic type alias that didn't + use its type parameter, which is illegal Rust code and caused compilation + errors. [#820](https://github.com/rust-lang/rust-bindgen/issues/820) + +* The generated size, alignment, and field offset unit tests now have stable + names rather than sometimes including an internal identifier which is + inherently unstable. This was causing unnecessary diffs when folks were + checking in new versions of bindings into their VCS. + [#394](https://github.com/rust-lang/rust-bindgen/issues/394) + +* Fixed a bug where we would try and `derive(Debug, Default)` on structs that + had padding like `[u8; 33]`, which is larger than the largest array length for + which Rust will derive traits. This would cause compilation errors when + compiling the emitted bindings. + [#648](https://github.com/rust-lang/rust-bindgen/issues/648) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 001ad0e2be..9c28e198c9 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -1,112 +1,626 @@ -# Contributing to `servo/rust-bindgen` +# Contributing to `bindgen` Hi! We'd love to have your contributions! If you want help or mentorship, reach -out to us in a GitHub issue, or stop by #servo on irc.mozilla.org and introduce -yourself. - -* [Code of Conduct](#coc) -* [Filing an Issue](#issue) -* [Building](#building) -* [Testing](#tests) - * [Overview](#tests-overview) - * [Running All Tests](#tests-all) - * [Running a Single, Specific Test](#tests-one) - * [Authoring New Tests](#tests-new) -* [Debug Logging](#logs) - -## Code of Conduct +out to us in a GitHub issue, or stop by +[#rust on chat.mozilla.org](https://chat.mozilla.org/#/room/#rust:mozilla.org) +and introduce yourself. + + + + +- [Code of Conduct](#code-of-conduct) +- [Filing an Issue](#filing-an-issue) +- [Looking to Start Contributing to `bindgen`?](#looking-to-start-contributing-to-bindgen) +- [Prerequisites](#prerequisites) + - [`rustfmt` / `cargo fmt`](#rustfmt--cargo-fmt) +- [Building](#building) +- [Testing](#testing) + - [Overview](#overview) + - [Testing Bindings Generation](#testing-bindings-generation) + - [Testing Generated Bindings](#testing-generated-bindings) + - [Testing a Single Header's Bindings Generation and Compiling its Bindings](#testing-a-single-headers-bindings-generation-and-compiling-its-bindings) + - [Authoring New Tests](#authoring-new-tests) + - [Test Expectations and `libclang` Versions](#test-expectations-and-libclang-versions) + - [Integration Tests](#integration-tests) + - [Fuzzing `bindgen` with `csmith`](#fuzzing-bindgen-with-csmith) + - [Property tests for `bindgen` with `quickchecking`](#property-tests-for-bindgen-with-quickchecking) +- [Code Overview](#code-overview) + - [Implementing new options using `syn`](#implementing-new-options-using-syn) +- [Pull Requests and Code Reviews](#pull-requests-and-code-reviews) +- [Generating Graphviz Dot Files](#generating-graphviz-dot-files) +- [Debug Logging](#debug-logging) +- [Using `creduce` to Minimize Test Cases](#using-creduce-to-minimize-test-cases) + - [Getting `creduce`](#getting-creduce) + - [Isolating Your Test Case](#isolating-your-test-case) + - [Writing a Predicate Script](#writing-a-predicate-script) +- [Cutting a new bindgen release](#cutting-a-new-bindgen-release) + - [Updating the changelog](#updating-the-changelog) + - [Merge to `main`](#merge-to-main) + - [Tag and publish](#tag-and-publish) + - [Create a new release on Github](#create-a-new-release-on-github) + - [What to do if a Github release fails](#what-to-do-if-a-github-release-fails) + - [Create a new crates.io release](#create-a-new-cratesio-release) + + + +## Code of Conduct We abide by the [Rust Code of Conduct][coc] and ask that you do as well. -[coc]: https://www.rust-lang.org/en-US/conduct.html +[coc]: https://www.rust-lang.org/policies/code-of-conduct -## Filing an Issue +## Filing an Issue Think you've found a bug? File an issue! To help us understand and reproduce the issue, provide us with: -* A (preferrably reduced) C/C++ header file that reproduces the issue -* The `bindgen` flags used to reproduce the issue with the header file -* The expected `bindgen` output -* The actual `bindgen` output -* The [debugging logs](#logs) generated when running `bindgen` on this testcase +- A (preferably reduced) C/C++ header file that reproduces the issue +- The `bindgen` flags used to reproduce the issue with the header file +- The expected `bindgen` output +- The actual `bindgen` output +- The [debugging logs](#debug-logging) generated when running `bindgen` on this testcase -## Building +## Looking to Start Contributing to `bindgen`? -Build instructions are in the [README](./README.md). +- [Issues labeled "easy"](https://github.com/rust-lang/rust-bindgen/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy) +- [Issues labeled "less easy"](https://github.com/rust-lang/rust-bindgen/issues?q=is%3Aopen+is%3Aissue+label%3AE-less-easy) +- [Issues labeled "help wanted"](https://github.com/rust-lang/rust-bindgen/labels/help%20wanted) +- Still can't find something to work on? [Drop a comment here](https://github.com/rust-lang/rust-bindgen/issues/747) -Additionally, you may want to build and test with the `_docs` feature to ensure -that you aren't forgetting to document types and functions. CI will catch it if -you forget, but the turn around will be a lot slower ;) +## Prerequisites -``` -$ cargo build --features "llvm_stable _docs" -``` +### `rustfmt` / `cargo fmt` -## Testing +We use `nightly` channel for `rustfmt`, +so please set the appropriate setting in your editor/IDE for that. -### Overview +For rust-analyzer, you can set `rustfmt.extraArgs = ['+nightly']`. -Input C/C++ test headers reside in the `tests/headers` directory. The expected -output rust bindings live in `tests/expectations`; for example, -`tests/headers/my_header.h`'s expected generated rust bindings would be -`tests/expectations/my_header.rs`. +To check via command line, you can run `cargo +nightly fmt --check`. -The `tests/tools/run-bindgen.py` script runs `bindgen` on the test headers and -compares the results to the expectations. +## Building -### Running All Tests +To build the `bindgen` library and the `bindgen` executable: +```sh +cargo build ``` -$ cargo test [--features llvm_stable] + +If you installed multiple versions of llvm, it may not be able to locate the +latest version of `libclang`. In that case, you may want to either uninstall other +versions of llvm, or specify the path of the desired `libclang` explicitly: + +```sh +export LIBCLANG_PATH=path/to/clang-9.0/lib ``` -This spawns a `tests/tools/run-bindgen.py` subprocess for each test header. +## Testing + +### Overview + +Input C/C++ test headers reside in the `bindgen-tests/tests/headers` directory. Expected +output Rust bindings live in `bindgen-tests/tests/expectations/tests`. For example, +`bindgen-tests/tests/headers/my_header.h`'s expected generated Rust bindings would be +`bindgen-tests/tests/expectations/tests/my_header.rs`. -### Running a Single, Specific Test +There are also some integration tests in the `./bindgen-integration` crate, which uses `bindgen` to +generate bindings to some C++ code, and then uses the bindings, asserting that +values are what we expect them to be, both on the Rust and C++ side. +The generated and expected bindings are formatted with [`prettyplease`] before they are +compared. It is a default (but optional) dependency of `bindgen`, +so be sure to keep that in mind +(if you built `bindgen` with the `--no-default-features` option of Cargo). +Note also that `rustfmt` formatting is disabled for the `bindgen-tests/tests/expectations/` +directory tree, which helps avoid failing ui tests. + +Note: running `cargo test` from the root directory of `bindgen`'s repository does not +automatically test the generated bindings or run the integration tests. +These steps must be performed manually when needed. + +### Testing Bindings Generation + +To regenerate bindings from the corpus of test headers in `bindgen-tests/tests/headers` and +compare them against the expected bindings in `bindgen-tests/tests/expectations/tests`, run: + +```sh +cargo test ``` -$ ./tests/tools/run-bindgen.py ./target/debug/bindgen ./tests/headers/some_header.h + +As long as you aren't making any changes to `bindgen`'s output, running this +should be sufficient to test your local modifications. + +You may set the `BINDGEN_OVERWRITE_EXPECTED` environment variable to overwrite +the expected bindings with `bindgen`'s current output: + +```sh +BINDGEN_OVERWRITE_EXPECTED=1 cargo test ``` -To learn more about the options available with `run-bindgen.py`: +If you set the `BINDGEN_TESTS_DIFFTOOL` environment variable, `cargo test` will +execute `BINDGEN_TESTS_DIFFTOOL /path/of/expected/output /path/of/actual/output` +when the expected output differs from the actual output. You can use this to +hand check differences by setting it to e.g. "meld" (assuming you have meld +installed). + +If you're not changing command line arguments, you may want to set +`BINDGEN_DISABLE_ROUNDTRIP_TEST` to avoid a lot of tests for round-tripping of +those. +### Testing Generated Bindings + +If your local changes are introducing expected modifications in the +`bindgen-tests/tests/expectations/tests/*` bindings files, then you should test that the +generated bindings files still compile, and that their struct layout tests still +pass. Also, run the integration tests (see below). + +You can do this with these commands: + +```sh +cd bindgen-tests/tests/expectations +cargo test ``` -$ ./tests/tools/run-bindgen.py --help + +### Testing a Single Header's Bindings Generation and Compiling its Bindings + +Note: You will need to install [graphviz](https://graphviz.org/) since that +is a dependency for running `test-one.sh`. + +Sometimes it's useful to work with one test header from start (generating +bindings for it) to finish (compiling the bindings and running their layout +tests). This can be done with the `bindgen-tests/tests/test-one.sh` script. It supports fuzzy +searching for test headers. For example, to test +`tests/headers/what_is_going_on.hpp`, execute this command: + +```sh +./bindgen-tests/tests/test-one.sh going ``` -### Authoring New Tests +Note that `test-one.sh` does not recompile `bindgen`, so if you change the code, +you'll need to rebuild it before running the script again. + +### Authoring New Tests -To add a new test header to the suite, simply put it in the `tests/headers` -directory. Next, run the `run-bindgen.py` script with the new test header, which -will generate the initial expected output rust bindings. +To add a new test header to the suite, simply put it in the `bindgen-tests/tests/headers` +directory. Next, run `bindgen` to generate the initial expected output Rust +bindings. Put those in `bindgen-tests/tests/expectations/tests`. If your new test requires certain flags to be passed to `bindgen`, you can specify them at the top of the test header, with a comment like this: +`new_test_header.hpp`: + ```c // bindgen-flags: --enable-cxx-namespaces -- -std=c++14 ``` -If your new test requires `bindgen` to be built with certain features, you can -specify the required features at the top of the test header in a similar manner: +Then verify the new Rust bindings compile and pass their layout tests: -```c -// bingden-features: llvm_stable +```sh +cd bindgen-tests/tests/expectations +cargo test new_test_header ``` -## Debug Logging +### Test Expectations and `libclang` Versions + +If a test generates different bindings across different `libclang` versions (for +example, because we take advantage of better/newer APIs when possible), then you +can add multiple test expectations, one for each supported `libclang` +version. Instead of having a single `bindgen-tests/tests/expectations/tests/my_test.rs` file, +add each of: + +- `bindgen-tests/tests/expectations/tests/libclang-16/my_test.rs` +- `bindgen-tests/tests/expectations/tests/libclang-9/my_test.rs` + +If you need to update the test expectations for a test file that generates +different bindings for different `libclang` versions, you *don't* need to have +many versions of `libclang` installed locally. Just make a work-in-progress pull +request, and then when CI fails, it will log a diff of the +expectations. Use the diff to patch the appropriate expectation file locally and +then update your pull request. + +Usually, `bindgen`'s test runner can infer which version of `libclang` you +have. If for some reason it can't, you can force a specific `libclang` version +to check the bindings against with a cargo feature: + +```sh +cargo test --features __testing_only_libclang_$VERSION +``` + +depending on which version of `libclang` you have installed. + +### Integration Tests + +The `./bindgen-integration` crate uses `bindgen` to +generate bindings to some C++ code, and then uses the bindings, asserting that +values are what we expect them to be, both on the Rust and C++ side. + +To run the integration tests, issue the following: + +```sh +cd bindgen-integration +cargo test +``` + +### Fuzzing `bindgen` with `csmith` + +We <3 finding hidden bugs and the people who help us find them! One way to help +uncover hidden bugs is by running `csmith` to generate random headers to test +`bindgen` against. + +See [./csmith-fuzzing/README.md](./csmith-fuzzing/README.md) for details. + +### Property tests for `bindgen` with `quickchecking` + +The `tests/quickchecking` crate generates property tests for `bindgen`. +From the crate's directory you can run the tests with `cargo run`. For details +on additional configuration including how to preserve / inspect the generated +property tests, see +[`./tests/quickchecking/README.md`](./tests/quickchecking/README.md). + +## Code Overview + +`bindgen` takes C and C++ header files as input and generates corresponding Rust +`#[repr(C)]` type definitions and `extern` foreign function declarations. + +First, we use `libclang` to parse the input headers. See `src/clang.rs` for our +Rust-y wrappers over the raw C `libclang` API that the `clang-sys` crate +exposes. We walk over `libclang`'s AST and construct our own internal +representation (IR). The `ir` module and submodules (`src/ir/*`) contain the IR +type definitions and `libclang` AST into IR parsing code. + +The umbrella IR type is the `Item`. It contains various nested `enum`s that let +us drill down and get more specific about the kind of construct that we're +looking at. Here is a summary of the IR types and their relationships: + +- `Item` contains: + - An `ItemId` to uniquely identify it. + - An `ItemKind`, which is one of: + - A `Module`, which is originally a C++ namespace and becomes a Rust + module. It contains the set of `ItemId`s of `Item`s that are defined + within it. + - A `Type`, which contains: + - A `Layout`, describing the type's size and alignment. + - A `TypeKind`, which is one of: + - Some integer type. + - Some float type. + - A `Pointer` to another type. + - A function pointer type, with `ItemId`s of its parameter types + and return type. + - An `Alias` to another type (`typedef` or `using X = ...`). + - A fixed size `Array` of `n` elements of another type. + - A `Comp` compound type, which is either a `struct`, `class`, + or `union`. This is potentially a template definition. + - A `TemplateInstantiation` referencing some template definition + and a set of template argument types. + - Etc... + - A `Function`, which contains: + - An ABI + - A mangled name + - a `FunctionKind`, which describes whether this function is a plain + function, method, static method, constructor, destructor, etc. + - The `ItemId` of its function pointer type. + - A `Var` representing a static variable or `#define` constant, which + contains: + - Its type's `ItemId` + - Optionally, a mangled name + - Optionally, a value + - An optional `clang::SourceLocation` that holds the first source code + location where the `Item` was encountered. + +The IR forms a graph of interconnected and inter-referencing types and +functions. The `ir::traversal` module provides IR graph traversal +infrastructure: edge kind definitions (base member vs field type vs function +parameter, etc...), the `Trace` trait to enumerate an IR thing's outgoing edges, +various traversal types. + +After constructing the IR, we run a series of analyses on it. These analyses do +everything from allocate logical bitfields into physical units, compute for +which types we can `#[derive(Debug)]`, to determining which implicit template +parameters a given type uses. The analyses are defined in +`src/ir/analysis/*`. They are implemented as fixed-point algorithms, using the +`ir::analysis::MonotoneFramework` trait. + +The final phase is generating Rust source text from the analyzed IR, and it is +defined in `src/codegen/*`. We use the `quote` crate, which provides the `quote!{ ... }` +macro for quasi-quoting Rust forms. Some options that affect the +generated Rust code are implemented using the [`syn`](https://docs.rs/syn) crate. + +### Implementing new options using `syn` + +If a new option can be implemented using the `syn` crate it should be added to +the `codegen::postprocessing` module by following these steps: + +- Introduce a new field to `BindgenOptions` for the option. +- Write a free function inside `codegen::postprocessing` implementing the + option. This function with the same name of the `BindgenOptions` field. +- Add a new value to the `codegen::postprocessing::PASSES` for the option using + the `pass!` macro. + +## Pull Requests and Code Reviews + +Ensure that each commit stands alone, and passes tests. This enables better `git +bisect`ing when needed. If your commits do not stand on their own, then rebase +them on top of the latest main and squash them into a single commit. + +All pull requests undergo code review before merging. To request review, comment +`r? @github_username_of_reviewer`. They we will respond with `r+` to approve the +pull request, or may leave feedback and request changes to the pull request. Any +changes should be squashed into the original commit. + +Unsure who to ask for review? Ask any of: + +- `@emilio` +- `@pvdrz` + +More resources: + +- [Servo's GitHub Workflow](https://github.com/servo/servo/wiki/Github-workflow) +- [Beginner's Guide to Rebasing and Squashing](https://github.com/servo/servo/wiki/Beginner's-guide-to-rebasing-and-squashing) + +## Generating Graphviz Dot Files + +We can generate [Graphviz](http://graphviz.org/pdf/dotguide.pdf) dot files from +our internal representation of a C/C++ input header, and then you can create a +PNG or PDF from it with Graphviz's `dot` program. This is very useful when +debugging bindgen! + +First, make sure you have Graphviz and `dot` installed: + +```sh +brew install graphviz # OS X +sudo dnf install graphviz # Fedora +# Etc... +``` + +Then, use the `--emit-ir-graphviz` flag to generate a `dot` file from our IR: + +```sh +cargo run -- example.hpp --emit-ir-graphviz output.dot +``` + +Finally, convert the `dot` file to an image: + +```sh +dot -Tpng output.dot -o output.png +``` + +The final result will look something like this: + +[![An example graphviz rendering of our IR](./example-graphviz-ir.png)](./example-graphviz-ir.png) + +## Debug Logging To help debug what `bindgen` is doing, you can define the environment variable `RUST_LOG=bindgen` to get a bunch of debugging log spew. +```sh +RUST_LOG=bindgen ./target/debug/bindgen [flags...] ~/path/to/some/header.h ``` -$ RUST_LOG=bindgen ./target/debug/bindgen [flags...] ~/path/to/some/header.h + +This logging can also be used when debugging failing tests: + +```sh +RUST_LOG=bindgen cargo test ``` -This logging can also be used when debugging failing tests under -`run-bindgen.py`: +## Using `creduce` to Minimize Test Cases + +If you find a test case that triggers an unexpected panic in `bindgen`, causes +`bindgen` to emit bindings that won't compile, define structs with the wrong +size/alignment, or results in any other kind of incorrectness, then using +`creduce` can help reduce the test case to a minimal one that still exhibits +that same bad behavior. + +***Reduced test cases are SUPER helpful when filing bug reports!*** + +### Getting `creduce` +Often, you can install `creduce` from your OS's package manager: + +```sh +sudo apt install creduce +brew install creduce +# Etc... ``` -$ RUST_LOG=bindgen ./tests/tools/run-bindgen.py ./target/debug/bindgen tests/headers/whatever.h + +Otherwise, follow [these instructions](https://github.com/csmith-project/creduce/blob/master/INSTALL.md) for building and/or installing `creduce`. + +Running `creduce` requires two things: + +1. Your isolated test case, and + +2. A script to act as a predicate script describing whether the behavior you're + trying to isolate occurred. + +With those two things in hand, running `creduce` looks like this: + +```sh +creduce ./predicate.sh ./isolated-test-case.h ``` + +### Isolating Your Test Case + +If you're using `bindgen` as a command line tool, pass +`--dump-preprocessed-input` flag. + +If you're using `bindgen` as a Rust library, invoke the +`bindgen::Builder::dump_preprocessed_input` method where you call +`bindgen::Builder::generate`. + +Afterwards, there should be a `__bindgen.i` or `__bindgen.ii` file containing +the combined and preprocessed input headers, which is usable as an isolated, +standalone test case. + +### Writing a Predicate Script + +Writing a `predicate.sh` script for a `bindgen` test case is straightforward. We +already have a general purpose predicate script that you can use, you just have +to wrap and configure it. + +```bash +#!/usr/bin/env bash + +# Exit the script with a nonzero exit code if: +# * any individual command finishes with a nonzero exit code, or +# * we access any undefined variable. +set -eu + +# Invoke the general purpose predicate script that comes in the +# `bindgen` repository. +# +# You'll need to replace `--whatever-flags` with things that are specific to the +# incorrectness you're trying to pin down. See below for details. +path/to/rust-bindgen/csmith-fuzzing/predicate.py \ + --whatever-flags \ + ./isolated-test-case.h +``` + +When hunting down a particular panic emanating from inside `bindgen`, you can +invoke `predicate.py` like this: + +```bash +path/to/rust-bindgen/csmith-fuzzing/predicate.py \ + --expect-bindgen-fail \ + --bindgen-grep "thread main panicked at ''" \ + ./isolated-test-case.h +``` + +Alternatively, when hunting down a bad `#[derive(Eq)]` that is causing `rustc` +to fail to compile `bindgen`'s emitted bindings, you can invoke `predicate.py` +like this: + +```bash +# the rustc-grep argument expects a regex, thus escape where necessary +path/to/rust-bindgen/csmith-fuzzing/predicate.py \ + --bindings-grep NameOfTheStructThatIsErroneouslyDerivingEq \ + --expect-compile-fail \ + --rustc-grep 'error\[E0277\]: the trait bound `f64: std::cmp::Eq` is not satisfied' \ + ./isolated-test-case.h +``` + +Or, when minimizing a failing layout test in the compiled bindings, you can +invoke `predicate.py` like this: + +```bash +path/to/rust-bindgen/csmith-fuzzing/predicate.py \ + --bindings-grep MyStruct \ + --expect-layout-tests-fail \ + --layout-tests-grep "thread 'bindgen_test_layout_MyStruct' panicked" \ + ./isolated-test-case.h +``` + +For details on all the flags that you can pass to `predicate.py`, run: + +```sh +path/to/rust-bindgen/csmith-fuzzing/predicate.py --help +``` + +And you can always write your own, arbitrary predicate script if you prefer. +(Although, maybe we should add extra functionality to `predicate.py` -- file an +issue if you think so!) + +`creduce` is *really* helpful and can cut hundreds of thousands of lines of test +case down to 5 lines. + +Happy bug hunting and test case reducing! + +[More information on using `creduce`.](https://embed.cs.utah.edu/creduce/using/) + +## Cutting a new bindgen release + +To cut a release, the following needs to happen: + +### Updating the changelog + +Update the CHANGELOG.md file with the changes from the last release. Something +like the following is a useful way to check what has landed: + +```sh +git log --oneline v0.62.0..HEAD +``` + +Also worth checking the [next-release +tag](https://github.com/rust-lang/rust-bindgen/pulls?q=is%3Apr+label%3Anext-release). +It is very important that you do not rename the `Unreleased` section of the +changelog as this will be done automatically using `cargo release` on a further +step. + +### Merge to `main` + +For regular releases, the changes above should end up in `main` before +publishing. For dot-releases of an old version (e.g., cherry-picking an +important fix) you can skip this. + +### Tag and publish + +Once you're in `main`. Remember to install `doctoc` by running: + +```sh +npm install doctoc +``` + +And then run: + +```sh +cargo release [patch|minor] --no-publish --execute +``` + +This does the following: + +- Bump the version. +- Turn the `Unreleased` section of the changelog into the section for the version being released. +- Update the table of contents of the changelog using `doctoc`. +- Tag (`git tag`) the HEAD commit +- Push (`git push`) to GitHub + +The `patch` and `minor` refer to semver concepts: + +- `patch` would bump **v0.68.1** to **v0.68.2** +- `minor` would bump **v0.68.2** to **v0.69.0** + +> NOTE: +> We use the `--no-publish` so that the crates are only published after the release is complete. +> This is automatic, provided the release CI job is successful. + +### Create a new release on Github + +The release is automated with the help of `.github/workflows/release.yml`, +and will only be created... + +- when a Git tag is pushed +- when all tests succeed + +While the tests are still running, +a draft GitHub release will be created, +to avoid notifying watchers of the repo should a CI step fail. + +If everything succeeds, +tarballs containing bindgen cli executables for Linux and MacOS +(both for x86 and Arm) will be created. +See `[workspace.metadata.dist]` section in `Cargo.toml` for the configuration. + +To update the release configuration, +when a new `cargo-dist` is available: + +```sh +cargo dist init # from "cargo install cargo-dist" +``` + +### What to do if a Github release fails + +If the release process fails after you run `cargo release`, you can manually +delete the tag and release from Github. Also remember to delete the tag locally +by running `git tag -d`. Once all the extra changes are in the `main` branch, +you can trigger a release by creating a new tag using `git tag` and push it +using `git push --tag`. + +### Create a new crates.io release + +Go to [the Publish +workflow](https://github.com/rust-lang/rust-bindgen/actions/workflows/publish.yml) +and run a new workflow using the "Run Workflow" button. + +Remember that crates.io releases cannot be deleted! + +[`prettyplease`]: https://github.com/dtolnay/prettyplease diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 0000000000..28bc2732ac --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,737 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "aho-corasick" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" +dependencies = [ + "memchr", +] + +[[package]] +name = "annotate-snippets" +version = "0.11.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "710e8eae58854cdc1790fcb56cca04d712a17be849eeb81da2a724bf4bae2bc4" +dependencies = [ + "anstyle", + "unicode-width", +] + +[[package]] +name = "anstream" +version = "0.6.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "301af1932e46185686725e0fad2f8f2aa7da69dd70bf6ecc44d6b703844a3933" +dependencies = [ + "anstyle", + "anstyle-parse", + "anstyle-query", + "anstyle-wincon", + "colorchoice", + "is_terminal_polyfill", + "utf8parse", +] + +[[package]] +name = "anstyle" +version = "1.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "862ed96ca487e809f1c8e5a8447f6ee2cf102f846893800b20cebdf541fc6bbd" + +[[package]] +name = "anstyle-parse" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2" +dependencies = [ + "utf8parse", +] + +[[package]] +name = "anstyle-query" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c8bdeb6047d8983be085bab0ba1472e6dc604e7041dbf6fcd5e71523014fae9" +dependencies = [ + "windows-sys", +] + +[[package]] +name = "anstyle-wincon" +version = "3.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "403f75924867bb1033c59fbf0797484329750cfbe3c4325cd33127941fabc882" +dependencies = [ + "anstyle", + "once_cell_polyfill", + "windows-sys", +] + +[[package]] +name = "bindgen" +version = "0.72.0" +dependencies = [ + "annotate-snippets", + "bitflags", + "cexpr", + "clang-sys", + "clap", + "clap_complete", + "itertools", + "log", + "prettyplease", + "proc-macro2", + "quote", + "regex", + "rustc-hash", + "shlex", + "syn", +] + +[[package]] +name = "bindgen-cli" +version = "0.72.0" +dependencies = [ + "bindgen", + "env_logger 0.10.2", + "log", + "proc-macro2", + "shlex", +] + +[[package]] +name = "bindgen-integration" +version = "0.1.0" +dependencies = [ + "bindgen", + "cc", +] + +[[package]] +name = "bindgen-tests" +version = "0.1.0" +dependencies = [ + "bindgen", + "owo-colors", + "prettyplease", + "proc-macro2", + "regex", + "shlex", + "similar", + "syn", + "tempfile", +] + +[[package]] +name = "bitflags" +version = "2.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967" + +[[package]] +name = "block" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a" + +[[package]] +name = "cc" +version = "1.2.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c1599538de2394445747c8cf7935946e3cc27e9625f889d979bfb2aaf569362" +dependencies = [ + "shlex", +] + +[[package]] +name = "cexpr" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766" +dependencies = [ + "nom", +] + +[[package]] +name = "cfg-if" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268" + +[[package]] +name = "clang-sys" +version = "1.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4" +dependencies = [ + "glob", + "libc", + "libloading", +] + +[[package]] +name = "clap" +version = "4.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e578d6ec4194633722ccf9544794b71b1385c3c027efe0c55db226fc880865c" +dependencies = [ + "clap_builder", + "clap_derive", +] + +[[package]] +name = "clap_builder" +version = "4.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4df4df40ec50c46000231c914968278b1eb05098cf8f1b3a518a95030e71d1c7" +dependencies = [ + "anstream", + "anstyle", + "clap_lex", + "strsim", +] + +[[package]] +name = "clap_complete" +version = "4.4.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "abb745187d7f4d76267b37485a65e0149edd0e91a4cfcdd3f27524ad86cee9f3" +dependencies = [ + "clap", +] + +[[package]] +name = "clap_derive" +version = "4.4.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf9804afaaf59a91e75b022a30fb7229a7901f60c755489cc61c9b423b836442" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "clap_lex" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1" + +[[package]] +name = "colorchoice" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75" + +[[package]] +name = "either" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" + +[[package]] +name = "env_logger" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a19187fea3ac7e84da7dacf48de0c45d63c6a76f9490dae389aead16c243fce3" +dependencies = [ + "log", + "regex", +] + +[[package]] +name = "env_logger" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4cd405aab171cb85d6735e5c8d9db038c17d3ca007a4d2c25f337935c3d90580" +dependencies = [ + "humantime", + "is-terminal", + "log", + "regex", + "termcolor", +] + +[[package]] +name = "errno" +version = "0.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "778e2ac28f6c47af28e4907f13ffd1e1ddbd400980a9abd7c8df189bf578a5ad" +dependencies = [ + "libc", + "windows-sys", +] + +[[package]] +name = "fastrand" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be" + +[[package]] +name = "getrandom" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592" +dependencies = [ + "cfg-if", + "libc", + "wasi 0.11.1+wasi-snapshot-preview1", +] + +[[package]] +name = "getrandom" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4" +dependencies = [ + "cfg-if", + "libc", + "r-efi", + "wasi 0.14.2+wasi-0.2.4", +] + +[[package]] +name = "glob" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2" + +[[package]] +name = "heck" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8" + +[[package]] +name = "hermit-abi" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c" + +[[package]] +name = "humantime" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b112acc8b3adf4b107a8ec20977da0273a8c386765a3ec0229bd500a1443f9f" + +[[package]] +name = "is-terminal" +version = "0.4.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9" +dependencies = [ + "hermit-abi", + "libc", + "windows-sys", +] + +[[package]] +name = "is_terminal_polyfill" +version = "1.70.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf" + +[[package]] +name = "itertools" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285" +dependencies = [ + "either", +] + +[[package]] +name = "libc" +version = "0.2.174" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776" + +[[package]] +name = "libloading" +version = "0.8.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07033963ba89ebaf1584d767badaa2e8fcec21aedea6b8c0346d487d49c28667" +dependencies = [ + "cfg-if", + "windows-targets", +] + +[[package]] +name = "linux-raw-sys" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12" + +[[package]] +name = "log" +version = "0.4.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94" + +[[package]] +name = "malloc_buf" +version = "0.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb" +dependencies = [ + "libc", +] + +[[package]] +name = "memchr" +version = "2.7.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0" + +[[package]] +name = "minimal-lexical" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" + +[[package]] +name = "nom" +version = "7.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a" +dependencies = [ + "memchr", + "minimal-lexical", +] + +[[package]] +name = "objc" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1" +dependencies = [ + "malloc_buf", +] + +[[package]] +name = "once_cell" +version = "1.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" + +[[package]] +name = "once_cell_polyfill" +version = "1.70.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad" + +[[package]] +name = "owo-colors" +version = "4.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48dd4f4a2c8405440fd0462561f0e5806bd0f77e86f51c761481bdd4018b545e" + +[[package]] +name = "prettyplease" +version = "0.2.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "061c1221631e079b26479d25bbf2275bfe5917ae8419cd7e34f13bfc2aa7539a" +dependencies = [ + "proc-macro2", + "syn", +] + +[[package]] +name = "proc-macro2" +version = "1.0.95" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quickcheck" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "588f6378e4dd99458b60ec275b4477add41ce4fa9f64dcba6f15adccb19b50d6" +dependencies = [ + "env_logger 0.8.4", + "log", + "rand", +] + +[[package]] +name = "quickchecking" +version = "0.0.0" +dependencies = [ + "clap", + "quickcheck", + "tempfile", +] + +[[package]] +name = "quote" +version = "1.0.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom 0.2.16", +] + +[[package]] +name = "regex" +version = "1.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" + +[[package]] +name = "rustc-hash" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d" + +[[package]] +name = "rustix" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c71e83d6afe7ff64890ec6b71d6a69bb8a610ab78ce364b3352876bb4c801266" +dependencies = [ + "bitflags", + "errno", + "libc", + "linux-raw-sys", + "windows-sys", +] + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "similar" +version = "2.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa" + +[[package]] +name = "strsim" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623" + +[[package]] +name = "syn" +version = "2.0.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "tempfile" +version = "3.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e8a64e3985349f2441a1a9ef0b853f869006c3855f2cda6862a94d26ebb9d6a1" +dependencies = [ + "fastrand", + "getrandom 0.3.3", + "once_cell", + "rustix", + "windows-sys", +] + +[[package]] +name = "termcolor" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "tests_expectations" +version = "0.0.0" +dependencies = [ + "block", + "libloading", + "objc", +] + +[[package]] +name = "unicode-ident" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512" + +[[package]] +name = "unicode-width" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a1a07cc7db3810833284e8d372ccdc6da29741639ecc70c9ec107df0fa6154c" + +[[package]] +name = "utf8parse" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" + +[[package]] +name = "wasi" +version = "0.11.1+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + +[[package]] +name = "wasi" +version = "0.14.2+wasi-0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3" +dependencies = [ + "wit-bindgen-rt", +] + +[[package]] +name = "winapi-util" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb" +dependencies = [ + "windows-sys", +] + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_gnullvm", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "wit-bindgen-rt" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1" +dependencies = [ + "bitflags", +] diff --git a/Cargo.toml b/Cargo.toml index 65a8033b8d..edb0d35371 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,58 +1,98 @@ -[package] -authors = [ - "Jyun-Yan You ", - "Emilio Cobos Álvarez ", - "The Servo project developers", +[workspace] +resolver = "2" +members = [ + "bindgen", + "bindgen-cli", + "bindgen-integration", + "bindgen-tests", + "bindgen-tests/tests/quickchecking", + "bindgen-tests/tests/expectations", ] -build = "build.rs" -description = "A binding generator for Rust" -homepage = "https://github.com/servo/rust-bindgen" -keywords = ["bindings", "ffi", "code-generation"] -license = "BSD-3-Clause" -name = "bindgen" -readme = "README.md" -repository = "https://github.com/servo/rust-bindgen" -version = "0.17.0" - -[[bin]] -doc = false -name = "bindgen" - -[build-dependencies] -quasi_codegen = "0.20" - -[dependencies] -cfg-if = "0.1.0" -clang-sys = "0.8.0" -lazy_static = "0.1.*" -libc = "0.2" -log = "0.3" -env_logger = "0.3" -rustc-serialize = "0.3.19" -syntex_syntax = "0.44" -regex = "0.1" - -[dependencies.aster] -features = ["with-syntex"] -version = "0.28" - -[dependencies.clippy] -optional = true -version = "*" - -[dependencies.quasi] -features = ["with-syntex"] -version = "0.20" - -[features] -llvm_stable = [] -static = [] -# This feature only exists for CI -- don't use it! -_docs = [] - -[lib] -name = "bindgen" -path = "src/lib.rs" - -[[test]] -name = "tests" +default-members = [ + "bindgen", + "bindgen-cli", + "bindgen-tests", +] + +[workspace.package] +# If you change this, also update README.md +rust-version = "1.70.0" +edition = "2021" + +# All dependency version management is centralized here +[workspace.dependencies] +annotate-snippets = "0.11.4" +bindgen = { version = "0.72.0", path = "./bindgen", default-features = false } +bitflags = "2.2.1" +block = "0.1" +cc = "1.0" +cexpr = "0.6" +clang-sys = "1" +clap = "4" +clap_complete = "4" +env_logger = "0.10.0" +itertools = { version = ">=0.10,<0.15", default-features = false } +libloading = "0.8" +log = "0.4" +objc = "0.2" +owo-colors = "4.1.0" +prettyplease = "0.2.7" +proc-macro2 = "1.0.80" +quickcheck = "1.0" +quote = { version = "1", default-features = false } +regex = { version = "1.5.3", default-features = false } +rustc-hash = "2.1.0" +shlex = "1" +similar = "2.2.1" +syn = "2.0" +tempfile = "3" + +[workspace.lints.rust] +unused_qualifications = "warn" + +[workspace.lints.clippy] +pedantic = { level = "warn", priority = -1 } + +cast_possible_truncation = "allow" +cast_possible_wrap = "allow" +cast_precision_loss = "allow" +cast_sign_loss = "allow" +default_trait_access = "allow" +ignored_unit_patterns = "allow" +implicit_hasher = "allow" +items_after_statements = "allow" +match_same_arms = "allow" +maybe_infinite_iter = "allow" +missing_errors_doc = "allow" +missing_panics_doc = "allow" +module_name_repetitions = "allow" +must_use_candidate = "allow" +redundant_closure_for_method_calls = "allow" +return_self_not_must_use = "allow" +similar_names = "allow" +struct_excessive_bools = "allow" +struct_field_names = "allow" +unnecessary_wraps = "allow" +unreadable_literal = "allow" +used_underscore_binding = "allow" +wildcard_imports = "allow" + +# TODO +trivially_copy_pass_by_ref = "allow" +unused_self = "allow" + +# Theese seem to be ok to ignore for now +enum_glob_use = "allow" +too_many_lines = "allow" + +# Config for 'cargo release' +[workspace.metadata.release] +shared-version = true # ensures published packages share the same version +tag-name = "v{{version}}" +# Don't release any crate unless its manifest has `release = true` +release = false + +# The profile that 'cargo dist' will build with +[profile.dist] +inherits = "release" +lto = "thin" diff --git a/LICENSE b/LICENSE index 589b5326e6..62f55f45a1 100644 --- a/LICENSE +++ b/LICENSE @@ -1,28 +1,29 @@ -Copyright (c) 2013, Jyun-Yan You +BSD 3-Clause License +Copyright (c) 2013, Jyun-Yan You All rights reserved. Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions -are met: +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. -1. Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. -2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in the - documentation and/or other materials provided with the distribution. -3. Neither the name of the author nor the names of his contributors - may be used to endorse or promote products derived from this software - without specific prior written permission. +* Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. -THIS SOFTWARE IS PROVIDED BY THE AUTHORS "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 AUTHORS OR CONTRIBUTORS BE LIABLE +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. +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. diff --git a/Makefile b/Makefile deleted file mode 100644 index 384ce323c7..0000000000 --- a/Makefile +++ /dev/null @@ -1,34 +0,0 @@ - -TEST_HEADERS := $(wildcard tests/headers/*.h) $(wildcard tests/headers/*.hpp) - -TEST_TARGETS := $(TEST_HEADERS:.h=.rs) -TEST_TARGETS := $(TEST_TARGETS:.hpp=.rs) -TEST_TARGETS := $(patsubst tests/headers/%, tests/expectations/%, $(TEST_TARGETS)) - -BINDGEN := ./target/debug/bindgen - -.PHONY: $(BINDGEN) -$(BINDGEN): - [ -f $@ ] || cargo build --features llvm_stable - -.PHONY: test -test: - cargo test --features llvm_stable - - -.PHONY: regen-tests -regen-tests: $(BINDGEN) clean-tests $(TEST_TARGETS) - @echo > /dev/null - -.PHONY: clean-tests -clean-tests: - $(RM) $(TEST_TARGETS) - -# TODO: Add options to add flags and whatnot -tests/expectations/%.rs: tests/headers/%.h - @mkdir -p $(dir $@) - ./tests/tools/run-bindgen.py $(BINDGEN) $< $@ - -tests/expectations/%.rs: tests/headers/%.hpp - @mkdir -p $(dir $@) - ./tests/tools/run-bindgen.py $(BINDGEN) $< $@ diff --git a/README.md b/README.md index 47e7dd53a0..b35dee3bef 100644 --- a/README.md +++ b/README.md @@ -1,152 +1,89 @@ -# Servo's rust-bindgen +[![crates.io](https://img.shields.io/crates/v/bindgen.svg)](https://crates.io/crates/bindgen) +[![docs.rs](https://docs.rs/bindgen/badge.svg)](https://docs.rs/bindgen/) -A binding generator for the Rust language. +# `bindgen` -This is a fork of [crabtw/rust-bindgen](https://github.com/crabtw/rust-bindgen) -designed to work on C++ code as well. +**`bindgen` automatically generates Rust FFI bindings to C (and some C++) libraries.** -Currently this is being used for Servo's SpiderMonkey bindings, and also for -the [Stylo](https://public.etherpad-mozilla.org/p/stylo) project. +For example, given the C header `doggo.h`: -## Requirements +```c +typedef struct Doggo { + int many; + char wow; +} Doggo; -The current generator runs on with clang 3.8, but can also run with clang 3.9 -with more features (such as detection of inlined functions). - -### Installing clang 3.8 - -#### OSX - -``` -# brew install llvm38 +void eleven_out_of_ten_majestic_af(Doggo* pupper); ``` -#### On Debian-based Linuxes +`bindgen` produces Rust FFI code allowing you to call into the `doggo` library's +functions and use its types: -``` -# apt-get install llvm-3.8-dev libclang-3.8-dev -``` -Adding the LLVM repos to get version 3.8 may be necessary, see http://apt.llvm.org/. -#### Arch +```rust +/* automatically generated by rust-bindgen 0.99.9 */ -``` -# pacman -S clang clang-tools-extra -``` - -### Getting clang 3.9 - -#### From a package manager - -Clang 3.9 has ben released about a month ago, and some package managers already -provide it. - -For example, for MacPorts: +#[repr(C)] +pub struct Doggo { + pub many: ::std::os::raw::c_int, + pub wow: ::std::os::raw::c_char, +} -``` -$ port install clang-3.9 -$ LIBCLANG_PATH=/opt/local/libexec/llvm-3.9/lib \ - LD_LIBRARY_PATH=/opt/local/libexec/llvm-3.9/lib \ - cargo build +extern "C" { + pub fn eleven_out_of_ten_majestic_af(pupper: *mut Doggo); +} ``` -#### From source +## Users Guide -If your package manager doesn't yet offer Clang 3.9, you'll need to build from -source. For that, follow the instructions -[here](http://clang.llvm.org/get_started.html). +[📚 Read the `bindgen` users guide here! 📚](https://rust-lang.github.io/rust-bindgen) -Those instructions list optional steps. For bindgen: +## MSRV -* Checkout and build clang -* Checkout and build the extra-clang-tools -* Checkout and build the compiler-rt -* You do not need to checkout or build libcxx +The `bindgen` minimum supported Rust version is **1.70.0**. -## Building +The `bindgen-cli` minimum supported Rust version is **1.70.0**. -``` -$ cargo build --features llvm_stable -``` +No MSRV bump policy has been established yet, so MSRV may increase in any release. -If you want a build with extra features (llvm 3.9) then you can use: +The MSRV is the minimum Rust version that can be used to *compile* each crate. However, `bindgen` and `bindgen-cli` can generate bindings that are compatible with Rust versions below the current MSRV. -``` -$ LIBCLANG_PATH=path/to/clang-3.9/build/lib \ - LD_LIBRARY_PATH=path/to/clang-3.9/build/lib \ - cargo build -``` - -# Command Line Usage - -There are a few options documented when running `./bindgen --help`. Other -options might exist (see [the SpiderMonkey script][sm-script] and [the Stylo -scripts][stylo-scripts] to see how is it used inside the Servo organisation. - -## C++ Usage - -This fork of rust-bindgen can handle a number of C++ features. - -When passing in header files, the file will automatically be treated as C++ if -it ends in ``.hpp``. If it doesn't, ``-x c++`` can be used to force C++ mode. +Most of the time, the `bindgen-cli` crate will have a more recent MSRV than `bindgen` as crates such as `clap` require it. -## Annotations +## API Reference -The translation of classes, structs, enums, and typedefs can be adjusted using -annotations. Annotations are specifically formatted html tags inside doxygen -style comments. +[API reference documentation is on docs.rs](https://docs.rs/bindgen) -### `opaque` +## Environment Variables -The `opaque` annotation instructs bindgen to ignore all fields defined in -a struct/class. +In addition to the [library API](https://docs.rs/bindgen) and [executable command-line API][bindgen-cmdline], +`bindgen` can be controlled through environment variables. -```cpp -///
-``` - -### `hide` +End-users should set these environment variables to modify `bindgen`'s behavior without modifying the source code of direct consumers of `bindgen`. -The `hide` annotation instructs bindgen to ignore the struct/class/field/enum -completely. - -``` -///
-``` - -### `replaces` - -The `replaces` annotation can be used to use a type as a replacement for other -(presumably more complex) type. This is used in Stylo to generate bindings for -structures that for multiple reasons are too complex for bindgen to understand. - -For example, in a C++ header: - -```cpp -/** - *
- */ -template -class nsTArray_Simple { - T* mBuffer; -public: - // The existence of a destructor here prevents bindgen from deriving the Clone - // trait via a simple memory copy. - ~nsTArray_Simple() {}; -}; -``` +- `BINDGEN_EXTRA_CLANG_ARGS`: extra arguments to pass to `clang` + - Arguments are whitespace-separated + - Use shell-style quoting to pass through whitespace + - Examples: + - Specify alternate sysroot: `--sysroot=/path/to/sysroot` + - Add include search path with spaces: `-I"/path/with spaces"` +- `BINDGEN_EXTRA_CLANG_ARGS_`: similar to `BINDGEN_EXTRA_CLANG_ARGS`, + but used to set per-target arguments to pass to clang. Useful to set system include + directories in a target-specific way in cross-compilation environments with multiple targets. + Has precedence over `BINDGEN_EXTRA_CLANG_ARGS`. -That way, after code generation, the bindings for the `nsTArray` type are -the ones that would be generated for `nsTArray_Simple`. +Additionally, `bindgen` uses `libclang` to parse C and C++ header files. +To modify how `bindgen` searches for `libclang`, see the [`clang-sys` documentation][clang-sys-env]. +For more details on how `bindgen` uses `libclang`, see the [`bindgen` users guide][bindgen-book-clang]. -### `nocopy` +## Releases -The `nocopy` annotation is used to prevent bindgen to autoderive the `Copy` -and `Clone` traits for a type. +We don't follow a specific release calendar, but if you need a release please +file an issue requesting that (ping `@emilio` for increased effectiveness). -# Macro Usage +## Contributing -This mode isn't actively maintained, so no promises are made around it. Check -out the upstream documentation for info about how it *should* work. +[See `CONTRIBUTING.md` for hacking on `bindgen`!](./CONTRIBUTING.md) -[sm-script]: https://github.com/servo/rust-mozjs/blob/master/etc/bindings.sh -[stylo-scripts]: https://github.com/servo/servo/tree/master/ports/geckolib/gecko_bindings/tools +[bindgen-cmdline]: https://rust-lang.github.io/rust-bindgen/command-line-usage.html +[clang-sys-env]: https://github.com/KyleMayes/clang-sys#environment-variables +[bindgen-book-clang]: https://rust-lang.github.io/rust-bindgen/requirements.html#clang diff --git a/appveyor.yml b/appveyor.yml new file mode 100644 index 0000000000..ffb74eedc6 --- /dev/null +++ b/appveyor.yml @@ -0,0 +1,57 @@ +environment: + RUST_BACKTRACE: 1 + RUST_CHANNEL: "%Configuration%" + matrix: + - TARGET: gnu + LLVM_VERSION: 9.0.0-1 + BINDGEN_FEATURES: __testing_only_libclang_9 + - TARGET: gnu + LLVM_VERSION: 16.0.4 + BINDGEN_FEATURES: __testing_only_libclang_16 + - TARGET: msvc + LLVM_VERSION: 9.0.0 + BINDGEN_FEATURES: __testing_only_libclang_9 + - TARGET: msvc + LLVM_VERSION: 16.0.4 + BINDGEN_FEATURES: __testing_only_libclang_16 + +configuration: +- stable +- nightly + +platform: + - x64 + - x86 + +branches: + only: + - main + +install: + - if %PLATFORM% == x86 (set RUST_PLATFORM=i686&set MINGW_BITS=32) else (set RUST_PLATFORM=x86_64&set MINGW_BITS=64) + - echo %RUST_CHANNEL% + - echo %RUST_PLATFORM% + - echo %MINGW_BITS% + - echo %RUST_PLATFORM%-pc-windows-%TARGET% + # install Rust + - appveyor-retry appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe + - rustup-init.exe -y --default-host %RUST_PLATFORM%-pc-windows-%TARGET% --default-toolchain %RUST_CHANNEL% + - set PATH=%PATH%;C:\Users\appveyor\.cargo\bin + # install LLVM for GNU + - if %TARGET%==gnu set PATH=C:\msys64\mingw%MINGW_BITS%\bin;C:\msys64\usr\bin\;%PATH% + - if %TARGET%==gnu set "MINGW_URL=http://repo.msys2.org/mingw/%RUST_PLATFORM%/mingw-w64-%RUST_PLATFORM%" + - if %TARGET%==gnu set "URL_VER=%LLVM_VERSION%-any.pkg.tar.xz" + - if %TARGET%==gnu bash -lc "pacman -U --noconfirm $MINGW_URL-clang-$URL_VER $MINGW_URL-llvm-$URL_VER" + - if %TARGET%==gnu bash -lc "clang --version" + # install LLVM for MSVC + - if %TARGET%==msvc appveyor-retry appveyor DownloadFile http://releases.llvm.org/%LLVM_VERSION%/LLVM-%LLVM_VERSION%-win64.exe -FileName llvm-installer.exe + - if %TARGET%==msvc 7z x llvm-installer.exe -oc:\llvm-binary + - if %TARGET%==msvc set PATH=C:\llvm-binary\bin;%PATH% + - if %TARGET%==msvc where clang + - if %TARGET%==msvc clang --version + +build_script: + - if %TARGET%==msvc .\ci\test.bat + - if %TARGET%==gnu bash -lc "export BINDGEN_FEATURES=$BINDGEN_FEATURES; cd $APPVEYOR_BUILD_FOLDER; ./ci/test.sh" + +test: off diff --git a/bindgen-cli/Cargo.toml b/bindgen-cli/Cargo.toml new file mode 100644 index 0000000000..e5d49a6ecc --- /dev/null +++ b/bindgen-cli/Cargo.toml @@ -0,0 +1,49 @@ +lints.workspace = true + +[package] +authors = [ + "The rust-bindgen project contributors", +] +description = "Automatically generates Rust FFI bindings to C and C++ libraries." +keywords = ["bindings", "ffi", "code-generation"] +categories = ["external-ffi-bindings", "development-tools::ffi"] +license = "BSD-3-Clause" +name = "bindgen-cli" +readme = "../README.md" +repository = "https://github.com/rust-lang/rust-bindgen" +documentation = "https://docs.rs/bindgen" +homepage = "https://rust-lang.github.io/rust-bindgen/" +version = "0.72.0" +rust-version.workspace = true +edition.workspace = true + +[[bin]] +path = "main.rs" +name = "bindgen" + +[dependencies] +bindgen = { workspace = true, features = ["__cli", "experimental", "prettyplease"] } +env_logger = { workspace = true, optional = true } +log = { workspace = true, optional = true } +proc-macro2.workspace = true +shlex.workspace = true + +[features] +default = ["logging", "runtime"] +logging = ["bindgen/logging", "dep:env_logger", "dep:log"] +static = ["bindgen/static"] +runtime = ["bindgen/runtime"] +prettyplease = ["bindgen/prettyplease"] + +## The following features are for internal use and they shouldn't be used if +## you're not hacking on bindgen +# Features used for CI testing +__testing_only_extra_assertions = ["bindgen/__testing_only_extra_assertions"] +__testing_only_libclang_9 = ["bindgen/__testing_only_libclang_9"] +__testing_only_libclang_16 = ["bindgen/__testing_only_libclang_16"] + +[package.metadata.release] +release = true + +[package.metadata.dist] +dist = true diff --git a/bindgen-cli/LICENSE b/bindgen-cli/LICENSE new file mode 120000 index 0000000000..ea5b60640b --- /dev/null +++ b/bindgen-cli/LICENSE @@ -0,0 +1 @@ +../LICENSE \ No newline at end of file diff --git a/bindgen-cli/main.rs b/bindgen-cli/main.rs new file mode 100644 index 0000000000..2d8d370ef1 --- /dev/null +++ b/bindgen-cli/main.rs @@ -0,0 +1,74 @@ +use std::env; + +use bindgen::builder_from_flags; + +#[cfg(feature = "logging")] +fn clang_version_check() { + let version = bindgen::clang_version(); + let expected_version = if cfg!(feature = "__testing_only_libclang_16") { + Some((16, 0)) + } else if cfg!(feature = "__testing_only_libclang_9") { + Some((9, 0)) + } else { + None + }; + + log::info!( + "Clang Version: {}, parsed: {:?}", + version.full, + version.parsed + ); + + if expected_version.is_some() { + // assert_eq!(version.parsed, version.parsed); + } +} + +pub fn main() { + #[cfg(feature = "logging")] + env_logger::init(); + + match builder_from_flags(env::args()) { + Ok((builder, output, verbose)) => { + #[cfg(feature = "logging")] + clang_version_check(); + + std::panic::set_hook(Box::new(move |info| { + if verbose { + print_verbose_err(); + } + eprintln!("{info}"); + })); + + let bindings = match builder.generate() { + Ok(bindings) => bindings, + Err(err) => { + eprintln!("Unable to generate bindings: {err}"); + std::process::exit(1) + } + }; + + let _ = std::panic::take_hook(); + + bindings.write(output).expect("Unable to write output"); + } + Err(error) => { + eprintln!("{error}"); + std::process::exit(1); + } + }; +} + +fn print_verbose_err() { + eprintln!("Bindgen unexpectedly panicked"); + eprintln!( + "This may be caused by one of the known-unsupported \ + things (https://rust-lang.github.io/rust-bindgen/cpp.html), \ + please modify the bindgen flags to work around it as \ + described in https://rust-lang.github.io/rust-bindgen/cpp.html" + ); + eprintln!( + "Otherwise, please file an issue at \ + https://github.com/rust-lang/rust-bindgen/issues/new" + ); +} diff --git a/bindgen-integration/.gitattributes b/bindgen-integration/.gitattributes new file mode 100644 index 0000000000..d42187e6fe --- /dev/null +++ b/bindgen-integration/.gitattributes @@ -0,0 +1,4 @@ +# Tell Github Linguist to avoid counting these C and C++ test inputs toward +# statistics. +*.h -linguist-detectable +*.cc -linguist-detectable diff --git a/bindgen-integration/Cargo.toml b/bindgen-integration/Cargo.toml new file mode 100644 index 0000000000..5c8c89d528 --- /dev/null +++ b/bindgen-integration/Cargo.toml @@ -0,0 +1,23 @@ +lints.workspace = true + +[package] +name = "bindgen-integration" +description = "A package to test various bindgen features" +version = "0.1.0" +authors = ["Emilio Cobos Álvarez "] +publish = false +build = "build.rs" +rust-version.workspace = true +edition.workspace = true + +[build-dependencies] +bindgen = { workspace = true, default-features = true, features = ["experimental"] } +cc.workspace = true + +[features] +static = ["bindgen/static"] +runtime = ["bindgen/runtime"] + +__testing_only_extra_assertions = ["bindgen/__testing_only_extra_assertions"] +__testing_only_libclang_9 = ["bindgen/__testing_only_libclang_9"] +__testing_only_libclang_16 = ["bindgen/__testing_only_libclang_16"] diff --git a/bindgen-integration/build.rs b/bindgen-integration/build.rs new file mode 100644 index 0000000000..1b7c2b3b82 --- /dev/null +++ b/bindgen-integration/build.rs @@ -0,0 +1,369 @@ +extern crate bindgen; + +use bindgen::callbacks::{ + DeriveInfo, IntKind, ItemInfo, MacroParsingBehavior, ParseCallbacks, Token, + TokenKind, +}; +use bindgen::{Builder, EnumVariation, Formatter}; +use std::collections::HashSet; +use std::env; +use std::path::PathBuf; +use std::sync::{Arc, Mutex, RwLock}; + +#[derive(Debug)] +struct MacroCallback { + macros: Arc>>, + seen_hellos: Mutex, + seen_funcs: Mutex, +} + +impl ParseCallbacks for MacroCallback { + fn will_parse_macro(&self, name: &str) -> MacroParsingBehavior { + self.macros.write().unwrap().insert(name.into()); + + if name == "MY_ANNOYING_MACRO" { + return MacroParsingBehavior::Ignore; + } + + MacroParsingBehavior::Default + } + + fn int_macro(&self, name: &str, _value: i64) -> Option { + match name { + "TESTMACRO_CUSTOMINTKIND_PATH" => Some(IntKind::Custom { + name: "crate::MacroInteger", + is_signed: true, + }), + + _ => None, + } + } + + fn str_macro(&self, name: &str, value: &[u8]) { + match name { + "TESTMACRO_STRING_EXPR" => { + assert_eq!(value, b"string"); + *self.seen_hellos.lock().unwrap() += 1; + } + "TESTMACRO_STRING_EXPANDED" | + "TESTMACRO_STRING" | + "TESTMACRO_INTEGER" => { + // The integer test macro is, actually, not expected to show up here at all -- but + // should produce an error if it does. + assert_eq!( + value, b"Hello Preprocessor!", + "str_macro handle received unexpected value" + ); + *self.seen_hellos.lock().unwrap() += 1; + } + _ => {} + } + } + + fn func_macro(&self, name: &str, value: &[&[u8]]) { + match name { + "TESTMACRO_NONFUNCTIONAL" => { + panic!("func_macro was called for a non-functional macro"); + } + "TESTMACRO_FUNCTIONAL_NONEMPTY(TESTMACRO_INTEGER)" => { + // Spaces are inserted into the right-hand side of a functional + // macro during reconstruction from the tokenization. This might + // change in the future, but it is safe by the definition of a + // token in C, whereas leaving the spaces out could change + // tokenization. + assert_eq!(value, &[b"-" as &[u8], b"TESTMACRO_INTEGER"]); + *self.seen_funcs.lock().unwrap() += 1; + } + "TESTMACRO_FUNCTIONAL_EMPTY(TESTMACRO_INTEGER)" => { + assert_eq!(value, &[] as &[&[u8]]); + *self.seen_funcs.lock().unwrap() += 1; + } + "TESTMACRO_FUNCTIONAL_TOKENIZED(a,b,c,d,e)" => { + assert_eq!( + value, + &[b"a" as &[u8], b"/", b"b", b"c", b"d", b"##", b"e"] + ); + *self.seen_funcs.lock().unwrap() += 1; + } + "TESTMACRO_FUNCTIONAL_SPLIT(a,b)" => { + assert_eq!(value, &[b"b", b",", b"a"]); + *self.seen_funcs.lock().unwrap() += 1; + } + "TESTMACRO_STRING_FUNC_NON_UTF8(x)" => { + assert_eq!( + value, + &[b"(" as &[u8], b"x", b"\"\xff\xff\"", b")"] + ); + *self.seen_funcs.lock().unwrap() += 1; + } + _ => { + // The system might provide lots of functional macros. + // Ensure we did not miss handling one that we meant to handle. + assert!(!name.starts_with("TESTMACRO_"), "name = {name}"); + } + } + } + + fn item_name(&self, item_info: ItemInfo) -> Option { + if item_info.name.starts_with("my_prefixed_") { + Some( + item_info + .name + .trim_start_matches("my_prefixed_") + .to_string(), + ) + } else if item_info.name.starts_with("MY_PREFIXED_") { + Some( + item_info + .name + .trim_start_matches("MY_PREFIXED_") + .to_string(), + ) + } else { + None + } + } + + // Test the "custom derives" capability by adding `PartialEq` to the `Test` struct. + fn add_derives(&self, info: &DeriveInfo<'_>) -> Vec { + if info.name == "Test" { + vec!["PartialEq".into()] + } else if info.name == "MyOrderedEnum" { + vec!["std::cmp::PartialOrd".into()] + } else if info.name == "TestDeriveOnAlias" { + vec!["std::cmp::PartialEq".into(), "std::cmp::PartialOrd".into()] + } else { + vec![] + } + } + + // Test the "custom attributes" capability. + fn add_attributes( + &self, + info: &bindgen::callbacks::AttributeInfo<'_>, + ) -> Vec { + if info.name == "Test" { + vec!["#[cfg_attr(test, derive(PartialOrd))]".into()] + } else { + vec![] + } + } + + fn modify_macro(&self, _name: &str, tokens: &mut Vec) { + // Handle macros dealing with bit positions of the format HI:LO + if tokens.len() == 4 && tokens[2].kind == TokenKind::Punctuation { + if let Ok(colon) = std::str::from_utf8(&tokens[2].raw) { + if colon != ":" { + return; + } + let high = match std::str::from_utf8(&tokens[1].raw) { + Ok(s) => { + if let Ok(val) = s.parse::() { + val + } else { + return; + } + } + Err(_) => { + return; + } + }; + + let low = match std::str::from_utf8(&tokens[3].raw) { + Ok(s) => { + if let Ok(val) = s.parse::() { + val + } else { + return; + } + } + Err(_) => { + return; + } + }; + let value: u32 = ((high as u32) << 16) | low as u32; + tokens[1] = Token::from(( + TokenKind::Literal, + value.to_string().as_bytes(), + )); + tokens.truncate(2); + } + } + } +} + +impl Drop for MacroCallback { + fn drop(&mut self) { + assert_eq!( + *self.seen_hellos.lock().unwrap(), + 3, + "str_macro handle was not called once for all relevant macros" + ); + assert_eq!( + *self.seen_funcs.lock().unwrap(), + 5, + "func_macro handle was not called once for all relevant macros" + ); + } +} + +#[derive(Debug)] +struct WrappedVaListCallback; + +impl ParseCallbacks for WrappedVaListCallback { + fn wrap_as_variadic_fn(&self, name: &str) -> Option { + Some(name.to_owned() + "_wrapped") + } +} + +fn setup_macro_test() { + cc::Build::new() + .cpp(true) + .file("cpp/Test.cc") + .include("include") + .compile("libtest.a"); + + let macros = Arc::new(RwLock::new(HashSet::new())); + + let out_path = PathBuf::from(env::var("OUT_DIR").unwrap()); + let out_rust_file = out_path.join("test.rs"); + let out_rust_file_relative = out_rust_file + .strip_prefix(env::current_dir().unwrap().parent().unwrap()) + .unwrap(); + let out_dep_file = out_path.join("test.d"); + + let bindings = Builder::default() + .formatter(Formatter::None) + .enable_cxx_namespaces() + .default_enum_style(EnumVariation::Rust { + non_exhaustive: false, + }) + .raw_line("pub use self::root::*;") + .raw_line("extern { fn my_prefixed_function_to_remove(i: i32); }") + .module_raw_line("root::testing", "pub type Bar = i32;") + .header("cpp/Test.h") + .clang_args(&["-x", "c++", "-std=c++11", "-I", "include"]) + .parse_callbacks(Box::new(MacroCallback { + macros: macros.clone(), + seen_hellos: Mutex::new(0), + seen_funcs: Mutex::new(0), + })) + .blocklist_function("my_prefixed_function_to_remove") + .constified_enum("my_prefixed_enum_to_be_constified") + .opaque_type("my_prefixed_templated_foo") + .new_type_alias("MyInt") + .new_type_alias("MyBool") + .new_type_alias("MyFloat") + .new_type_alias("MyChar") + .new_type_alias("TestDeriveOnAlias") + .depfile(out_rust_file_relative.display().to_string(), &out_dep_file) + .generate() + .expect("Unable to generate bindings"); + + assert!(macros.read().unwrap().contains("TESTMACRO")); + bindings + .write_to_file(&out_rust_file) + .expect("Couldn't write bindings!"); + + let observed_deps = + std::fs::read_to_string(out_dep_file).expect("Couldn't read depfile!"); + let expected_deps = format!( + "{}: cpp/Test.h include/stub.h", + out_rust_file_relative.display() + ); + assert_eq!( + observed_deps, expected_deps, + "including stub via include dir must produce correct dep path", + ); +} + +fn setup_wrap_static_fns_test() { + // GH-1090: https://github.com/rust-lang/rust-bindgen/issues/1090 + // set output directory under /target so it is easy to clean generated files + let out_path = PathBuf::from(env::var("OUT_DIR").unwrap()); + let out_rust_file = out_path.join("extern.rs"); + + let input_header_dir = PathBuf::from("../bindgen-tests/tests/headers/") + .canonicalize() + .expect("Cannot canonicalize libdir path"); + let input_header_file_path = input_header_dir.join("wrap-static-fns.h"); + let input_header_file_path_str = input_header_file_path + .to_str() + .expect("Path could not be converted to a str"); + + // generate external bindings with the external .c and .h files + #[allow(unused_mut)] + let mut builder = Builder::default() + .header(input_header_file_path_str) + .parse_callbacks(Box::new( + bindgen::CargoCallbacks::new().rerun_on_header_files(true), + )) + .parse_callbacks(Box::new(WrappedVaListCallback)) + .wrap_static_fns(true) + .wrap_static_fns_path( + out_path.join("wrap_static_fns").display().to_string(), + ) + .clang_arg("-DUSE_VA_HEADER"); + + // aarch64-linux has a bug, remove again when it is solved: + // https://github.com/rust-lang/rust-bindgen/issues/3234 + #[cfg(all(target_arch = "aarch64", target_os = "linux"))] + { + builder = builder.clang_arg("-DDISABLE_VA"); + } + + let bindings = builder.generate().expect("Unable to generate bindings"); + + println!("cargo:rustc-link-lib=static=wrap_static_fns"); // tell cargo to link libextern + println!("bindings generated: {bindings}"); + + let obj_path = out_path.join("wrap_static_fns.o"); + let lib_path = out_path.join("libwrap_static_fns.a"); + + // build the external files to check if they work + let mut command = std::process::Command::new("clang"); + command + .arg("-c") + .arg("-o") + .arg(&obj_path) + .arg(out_path.join("wrap_static_fns.c")) + .arg("-DUSE_VA_HEADER"); + + // aarch64-linux has a bug, remove again when it is solved: + // https://github.com/rust-lang/rust-bindgen/issues/3234 + #[cfg(all(target_arch = "aarch64", target_os = "linux"))] + { + command.arg("-DDISABLE_VA"); + } + + let clang_output = command.output().expect("`clang` command error"); + if !clang_output.status.success() { + panic!( + "Could not compile object file:\n{}", + String::from_utf8_lossy(&clang_output.stderr) + ); + } + + let ar_output = std::process::Command::new("ar") + .arg("rcs") + .arg(lib_path) + .arg(obj_path) + .output() + .expect("`ar` command error"); + + if !ar_output.status.success() { + panic!( + "Could not emit library file:\n{}", + String::from_utf8_lossy(&ar_output.stderr) + ); + } + + bindings + .write_to_file(out_rust_file) + .expect("Could not write bindings to the Rust file"); +} + +fn main() { + setup_macro_test(); + setup_wrap_static_fns_test(); +} diff --git a/bindgen-integration/cpp/Test.cc b/bindgen-integration/cpp/Test.cc new file mode 100644 index 0000000000..71a0a4b9c7 --- /dev/null +++ b/bindgen-integration/cpp/Test.cc @@ -0,0 +1,146 @@ +#include "Test.h" + +const int Test::COUNTDOWN[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 }; +const int* Test::COUNTDOWN_PTR = Test::COUNTDOWN; + +unsigned VirtualDestructor::sDestructorCount = 0; +VirtualDestructor::~VirtualDestructor() { + sDestructorCount++; +} + +unsigned InheritsFromVirtualDestructor::sDestructorCount = 0; +InheritsFromVirtualDestructor::InheritsFromVirtualDestructor() = default; + +InheritsFromVirtualDestructor::~InheritsFromVirtualDestructor() { + sDestructorCount++; +} + +const int* Test::countdown() { + return COUNTDOWN; +} + +const char* Test::name() { + return "Test"; +} + +Test::Test(int foo) + : m_int(foo) + , m_double(0.0) +{} + +Test::Test(double foo) + : m_int(0) + , m_double(foo) +{} + +AutoRestoreBool::AutoRestoreBool(bool* ptr) + : m_ptr(ptr) + , m_value(*ptr) +{} + +AutoRestoreBool::~AutoRestoreBool() { + *m_ptr = m_value; +} + +namespace bitfields { + +bool +First::assert(unsigned char first, + unsigned char second, + unsigned char third) +{ + return three_bits_byte_one == first && + six_bits_byte_two == second && + two_bits_byte_two == third; +} + +bool +Second::assert(int first, bool second) +{ + return thirty_one_bits == first && one_bit == second; +} + +bool +Third::assert(int first, bool second, ItemKind third) +{ + return flags == first && + is_whatever == second && + kind == third; +} + +bool +Fourth::assert(MyEnum tag, unsigned long ptr) +{ + return this->tag == tag && this->ptr == ptr; +} + +bool +Date2::assert(unsigned short nWeekDay, + unsigned short nMonthDay, + unsigned short nMonth, + unsigned short nYear, + unsigned short byte) +{ + return this->nWeekDay == nWeekDay && + this->nMonthDay == nMonthDay && + this->nMonth == nMonth && + this->nYear == nYear && + this->byte == byte; +} + +bool +Fifth::assert(unsigned short nWeekDay, + unsigned short nMonthDay, + unsigned short nMonth, + unsigned short nYear, + unsigned char byte) +{ + return this->nWeekDay == nWeekDay && + this->nMonthDay == nMonthDay && + this->nMonth == nMonth && + this->nYear == nYear && + this->byte == byte; +} + +bool +Sixth::assert(unsigned char byte, + unsigned char nWeekDay, + unsigned char nMonth, + unsigned char nMonthDay) { + return this->nWeekDay == nWeekDay && + this->nMonthDay == nMonthDay && + this->nMonth == nMonth && + this->byte == byte; +}; + +bool +Seventh::assert(bool first, + int second, + unsigned short third, + unsigned int fourth, + unsigned short fifth, + bool sixth, + int seventh) { + return this->first_one_bit == first && + this->second_thirty_bits == second && + this->third_two_bits == third && + this->fourth_thirty_bits == fourth && + this->fifth_two_bits == fifth && + this->sixth_one_bit == sixth && + this->seventh_thirty_bits == seventh; +}; + +} // namespace bitfields + +int my_prefixed_function_name() { + return 4; +} + +Coord coord(double x, double y, double z, double t) { + Coord res; + res.v[0] = x; + res.v[1] = y; + res.v[2] = z; + res.v[3] = t; + return res; +} diff --git a/bindgen-integration/cpp/Test.h b/bindgen-integration/cpp/Test.h new file mode 100644 index 0000000000..25858b2790 --- /dev/null +++ b/bindgen-integration/cpp/Test.h @@ -0,0 +1,261 @@ +#include "stub.h" // this bad path is made valid by a `-I include` clang arg + +#pragma once + +#define TESTMACRO + +#define TESTMACRO_INTEGER 42 +#define TESTMACRO_STRING "Hello Preprocessor!" +#define TESTMACRO_STRING_EXPANDED TESTMACRO_STRING +#define TESTMACRO_CUSTOMINTKIND_PATH 123 + +// The following two macros are parsed the same by cexpr, but are semantically +// different. +#define TESTMACRO_NONFUNCTIONAL (TESTMACRO_INTEGER) +#define TESTMACRO_FUNCTIONAL_EMPTY(TESTMACRO_INTEGER) +#define TESTMACRO_FUNCTIONAL_NONEMPTY(TESTMACRO_INTEGER)-TESTMACRO_INTEGER +#define TESTMACRO_FUNCTIONAL_TOKENIZED( a, b ,c,d,e ) a/b c d ## e +#define TESTMACRO_FUNCTIONAL_SPLIT( a, \ + b) b,\ + a +//#define TESTMACRO_INVALID("string") // A conforming preprocessor rejects this +#define TESTMACRO_STRING_EXPR ("string") +#define TESTMACRO_STRING_FUNC_NON_UTF8(x) (x "��") /* invalid UTF-8 on purpose */ + +#define TESTMACRO_COLON_VALUE 1:2 + +enum { + MY_ANNOYING_MACRO = +#define MY_ANNOYING_MACRO 1 + MY_ANNOYING_MACRO, +}; + +class Test { + int m_int; + double m_double; +public: + static const char* name(); + Test(int foo); + Test(double foo); + + static const int COUNTDOWN[]; + static const int* COUNTDOWN_PTR; + static const int* countdown(); +}; + +class ITest { + virtual void foo() = 0; +}; + +class VirtualDestructor { +public: + static unsigned sDestructorCount; + virtual ~VirtualDestructor() = 0; +}; + +class InheritsFromVirtualDestructor final : public VirtualDestructor { +public: + static unsigned sDestructorCount; + InheritsFromVirtualDestructor(); + ~InheritsFromVirtualDestructor() final; +}; + +namespace testing { + +typedef Test TypeAlias; + +} // namespace testing + +typedef testing::TypeAlias TypeAlias; + +namespace bitfields { + +struct First { + unsigned char three_bits_byte_one : 3; + // This starts a new byte, leaving 5 bits unused. + unsigned char :0; + + unsigned char six_bits_byte_two : 6; + unsigned char two_bits_byte_two : 2; + + /// Returns true if the bitfields match the arguments, false otherwise. + bool assert(unsigned char first, + unsigned char second, + unsigned char third); +}; + +struct Second { + int thirty_one_bits : 31; + bool one_bit : 1; + + /// Returns true if the bitfields match the arguments, false otherwise. + bool assert(int first, + bool second); +}; + +enum ItemKind { + ITEM_KIND_UNO = 0, + ITEM_KIND_DOS, + ITEM_KIND_TRES, +}; + +struct Third { + int flags : 28; + bool is_whatever : 1; + ItemKind kind : 3; + + /// Returns true if the bitfields match the arguments, false otherwise. + bool assert(int first, bool second, ItemKind third); +}; + +enum MyEnum { + ONE = 0, + TWO, + THREE, + FOUR, +}; + +struct Fourth { + MyEnum tag: 2; + unsigned long ptr: 48; + + /// Returns true if the bitfields match the arguments, false otherwise. + bool assert(MyEnum tag, unsigned long ptr); +}; + +struct Date2 { + unsigned short nWeekDay : 3; // 0..7 (3 bits) + unsigned short nMonthDay : 6; // 0..31 (6 bits) + unsigned short nMonth : 5; // 0..12 (5 bits) + unsigned short nYear : 8; // 0..100 (8 bits) + unsigned char byte : 8; + + bool assert(unsigned short nWeekDay, + unsigned short nMonthDay, + unsigned short nMonth, + unsigned short nYear, + unsigned short byte); +}; + + +struct Fifth { + unsigned short nWeekDay : 3; // 0..7 (3 bits) + unsigned short nMonthDay : 6; // 0..31 (6 bits) + unsigned short nMonth : 5; // 0..12 (5 bits) + unsigned short nYear : 8; // 0..100 (8 bits) + unsigned char byte; + + /// Returns true if the bitfields match the arguments, false otherwise. + bool assert(unsigned short nWeekDay, + unsigned short nMonthDay, + unsigned short nMonth, + unsigned short nYear, + unsigned char byte); +}; + +struct Sixth { + unsigned char byte; + unsigned char nWeekDay : 3; + unsigned char nMonth : 5; + unsigned char nMonthDay : 6; + + /// Returns true if the bitfields match the arguments, false otherwise. + bool assert(unsigned char byte, + unsigned char nWeekDay, + unsigned char nMonth, + unsigned char nMonthDay); +}; + +struct Seventh { + bool first_one_bit : 1; + unsigned int second_thirty_bits : 30; + unsigned short third_two_bits : 2; + unsigned int fourth_thirty_bits : 30; + unsigned short fifth_two_bits : 2; + bool sixth_one_bit : 1; + unsigned int seventh_thirty_bits : 30; + + /// Returns true if the bitfields match the arguments, false otherwise. + bool assert(bool first, + int second, + unsigned short third, + unsigned int fourth, + unsigned short fifth, + bool sixth, + int seventh); +}; + +} // namespace bitfields + +struct AutoRestoreBool { + bool* m_ptr; + bool m_value; + + AutoRestoreBool(bool*); + ~AutoRestoreBool(); +}; + +struct WithWChar { + wchar_t foo[30]; +}; + +// The names of the following items are unprefixed by the parse callbacks. +const int MY_PREFIXED_CONST_VALUE = 3; + +int my_prefixed_function_name(); + +struct my_prefixed_bar { + int foo; +}; + +struct my_prefixed_foo { + my_prefixed_bar member; +}; + +enum my_prefixed_enum_to_be_constified { + ONE = 1, + TWO, + THREE, +}; + +struct my_prefixed_baz { + char foo[30]; +}; + +template +struct my_prefixed_templated_foo { + T member; +}; + +my_prefixed_templated_foo TEMPLATED_CONST_VALUE; + +void my_prefixed_function_to_remove(); + +typedef union { + double v[4]; +} Coord; + +Coord coord(double x, double y, double z, double t); + +// Used to test custom derives on enum. See `test_custom_derive`. +enum MyOrderedEnum { + MICRON, + METER, + LIGHTYEAR, +}; + +// Used to test custom derives on new-type alias. See `test_custom_derive`. +typedef int TestDeriveOnAlias; + +// Used to test new-type alias constants. See `test_new_type_alias_const`. +typedef int MyInt; +const MyInt MY_INT = 5; + +typedef bool MyBool; +const MyBool MY_BOOL = true; + +typedef float MyFloat; +const MyFloat MY_FLOAT = 1.23f; + +typedef char MyChar; +const MyChar MY_CHAR = 'a'; diff --git a/bindgen-integration/include/stub.h b/bindgen-integration/include/stub.h new file mode 100644 index 0000000000..e69de29bb2 diff --git a/bindgen-integration/src/lib.rs b/bindgen-integration/src/lib.rs new file mode 100755 index 0000000000..8c31121b4b --- /dev/null +++ b/bindgen-integration/src/lib.rs @@ -0,0 +1,365 @@ +#![allow(warnings)] + +mod bindings { + include!(concat!(env!("OUT_DIR"), "/test.rs")); +} + +mod extern_bindings { + include!(concat!(env!("OUT_DIR"), "/extern.rs")); +} + +use std::ffi::CStr; +use std::mem; +use std::os::raw::c_int; + +use bindings::testing::Bar; // This type is generated from module_raw_line. + +type MacroInteger = isize; + +#[test] +fn test_static_array() { + let mut test = unsafe { bindings::Test_COUNTDOWN.as_ptr() }; + let expected = unsafe { bindings::Test_countdown() }; + let also_expected = unsafe { bindings::Test_COUNTDOWN_PTR }; + assert!(!test.is_null()); + assert_eq!(also_expected, expected); + assert_eq!(test, also_expected); + + let mut expected = 10; + unsafe { + loop { + assert_eq!(*test, expected); + if *test == 0 { + break; + } + test = test.offset(1); + expected -= 1; + } + } +} + +#[test] +fn test_static_method() { + let c_str = unsafe { bindings::Test::name() }; + let name = unsafe { CStr::from_ptr(c_str).to_string_lossy().into_owned() }; + assert_eq!(name, "Test", "Calling a static C++ method works!"); +} + +#[test] +fn test_constructor() { + let test = unsafe { bindings::Test::new(5) }; + assert_eq!(test.m_int, 5); + assert_eq!(test.m_double, 0.0); +} + +#[test] +fn test_overload() { + let test = unsafe { bindings::Test::new1(5.0) }; + assert_eq!(test.m_int, 0); + assert_eq!(test.m_double, 5.0); +} + +#[test] +fn test_bitfields_first() { + let mut first: bindings::bitfields::First = unsafe { mem::zeroed() }; + assert!(unsafe { first.assert(0, 0, 0) }); + first.set_three_bits_byte_one(2); + first.set_six_bits_byte_two(42); + first.set_two_bits_byte_two(1); + assert!(unsafe { first.assert(2, 42, 1) }); +} + +#[test] +fn test_bitfields_second() { + let mut second: bindings::bitfields::Second = unsafe { mem::zeroed() }; + assert!(unsafe { second.assert(0, false) }); + second.set_thirty_one_bits(1337); + second.set_one_bit(true); + assert!(unsafe { second.assert(1337, true) }); +} + +#[test] +fn test_bitfields_third() { + let mut third: bindings::bitfields::Third = unsafe { mem::zeroed() }; + assert!(unsafe { + third.assert(0, false, bindings::bitfields::ItemKind::ITEM_KIND_UNO) + }); + third.set_flags(12345); + third.set_is_whatever(true); + third.set_kind(bindings::bitfields::ItemKind::ITEM_KIND_TRES); + assert!(unsafe { + third.assert(12345, true, bindings::bitfields::ItemKind::ITEM_KIND_TRES) + }); +} + +#[test] +fn test_bitfields_fourth() { + let mut fourth: bindings::bitfields::Fourth = unsafe { mem::zeroed() }; + assert!(unsafe { fourth.assert(bindings::bitfields::MyEnum::ONE, 0) }); + + fourth.set_tag(bindings::bitfields::MyEnum::THREE); + fourth.set_ptr(0xdeadbeef); + assert!(unsafe { + fourth.assert(bindings::bitfields::MyEnum::THREE, 0xdeadbeef) + }); +} + +#[test] +fn test_bitfields_date2() { + let mut date: bindings::bitfields::Date2 = unsafe { mem::zeroed() }; + assert!(unsafe { date.assert(0, 0, 0, 0, 0) }); + + date.set_nWeekDay(6); // saturdays are the best + date.set_nMonthDay(20); + date.set_nMonth(11); + date.set_nYear(95); + date.set_byte(255); + assert!(unsafe { date.assert(6, 20, 11, 95, 255) }); +} + +#[test] +fn test_bitfields_fifth() { + let mut date: bindings::bitfields::Fifth = unsafe { mem::zeroed() }; + + assert!(unsafe { date.assert(0, 0, 0, 0, 0) }); + + date.byte = 255; // Set this first, to ensure we don't override it. + + date.set_nWeekDay(6); // saturdays are the best + date.set_nMonthDay(20); + date.set_nMonth(11); + date.set_nYear(95); + + assert!(unsafe { date.assert(6, 20, 11, 95, 255) }); +} + +#[test] +fn test_bitfields_sixth() { + let mut date: bindings::bitfields::Sixth = unsafe { mem::zeroed() }; + + assert!(unsafe { date.assert(0, 0, 0, 0) }); + + date.byte = 255; + date.set_nWeekDay(6); // saturdays are the best + date.set_nMonthDay(20); + date.set_nMonth(11); + + assert!(unsafe { date.assert(255, 6, 11, 20) }); +} + +#[test] +fn test_bitfields_seventh() { + let mut large: bindings::bitfields::Seventh = unsafe { mem::zeroed() }; + + assert!(unsafe { large.assert(false, 0, 0, 0, 0, false, 0) }); + + large.set_first_one_bit(true); + large.set_second_thirty_bits(375028802); + large.set_third_two_bits(2); + large.set_fourth_thirty_bits(643472885); + large.set_fifth_two_bits(3); + large.set_sixth_one_bit(true); + large.set_seventh_thirty_bits(1061657575); + + assert!(unsafe { + large.assert(true, 375028802, 2, 643472885, 3, true, 1061657575) + }); + + assert_eq!(large.first_one_bit(), true); + assert_eq!(large.second_thirty_bits(), 375028802); + assert_eq!(large.third_two_bits(), 2); + assert_eq!(large.fourth_thirty_bits(), 643472885); + assert_eq!(large.fifth_two_bits(), 3); + assert_eq!(large.sixth_one_bit(), true); + assert_eq!(large.seventh_thirty_bits(), 1061657575); +} + +#[test] +fn test_bitfield_constructors() { + use std::mem; + let mut first = bindings::bitfields::First { + _bitfield_1: bindings::bitfields::First::new_bitfield_1(1, 2, 3), + }; + assert!(unsafe { first.assert(1, 2, 3) }); + + let mut second = bindings::bitfields::Second { + _bindgen_align: [], + _bitfield_1: bindings::bitfields::Second::new_bitfield_1(1337, true), + }; + assert!(unsafe { second.assert(1337, true) }); + + let mut third = bindings::bitfields::Third { + _bindgen_align: [], + _bitfield_1: bindings::bitfields::Third::new_bitfield_1( + 42, + false, + bindings::bitfields::ItemKind::ITEM_KIND_TRES, + ), + }; + assert!(unsafe { + third.assert(42, false, bindings::bitfields::ItemKind::ITEM_KIND_TRES) + }); +} + +impl Drop for bindings::AutoRestoreBool { + fn drop(&mut self) { + unsafe { bindings::AutoRestoreBool::destruct(self) } + } +} + +#[test] +fn test_destructors() { + let mut v = true; + + { + let auto_restore = unsafe { bindings::AutoRestoreBool::new(&mut v) }; + v = false; + } + + assert!(v, "Should've been restored when going out of scope"); +} + +impl Drop for bindings::InheritsFromVirtualDestructor { + fn drop(&mut self) { + unsafe { + bindings::InheritsFromVirtualDestructor_InheritsFromVirtualDestructor_destructor(self) + } + } +} + +#[test] +fn test_virtual_dtor() { + unsafe { + { + let b = bindings::InheritsFromVirtualDestructor::new(); + // Let it go out of scope. + } + + assert_eq!(bindings::InheritsFromVirtualDestructor_sDestructorCount, 1); + assert_eq!(bindings::VirtualDestructor_sDestructorCount, 1); + } +} + +#[test] +fn test_item_rename() { + assert_eq!(bindings::CONST_VALUE, 3); + assert_eq!(unsafe { bindings::function_name() }, 4); + + let _foo = bindings::foo { + member: bindings::bar { foo: 2 }, + }; +} + +#[test] +fn test_matching_with_rename() { + assert_eq!(bindings::enum_to_be_constified_THREE, 3); + assert_eq!(unsafe { bindings::TEMPLATED_CONST_VALUE.0.len() }, 30); +} + +#[test] +fn test_macro_customintkind_path() { + let v: &dyn std::any::Any = &bindings::TESTMACRO_CUSTOMINTKIND_PATH; + assert!(v.is::()) +} + +#[test] +fn test_homogeneous_aggregate_float_union() { + unsafe { + let coord = &bindings::coord(1., 2., 3., 4.); + assert_eq!([1., 2., 3., 4.], coord.v) + } +} + +#[test] +fn test_custom_derive() { + // The `add_derives` callback should have added `#[derive(PartialEq)]` + // to the `Test` struct. If it didn't, this will fail to compile. + let test1 = unsafe { bindings::Test::new(5) }; + let test2 = unsafe { bindings::Test::new(6) }; + assert_ne!(test1, test2); + + // The `add_derives` callback should have added `#[derive(PartialOrd)]` + // to the `MyOrderedEnum` enum. If it didn't, this will fail to compile. + + let micron = unsafe { bindings::MyOrderedEnum::MICRON }; + let meter = unsafe { bindings::MyOrderedEnum::METER }; + let lightyear = unsafe { bindings::MyOrderedEnum::LIGHTYEAR }; + + assert!(meter < lightyear); + assert!(meter > micron); + + // The `add_derives` callback should have added `#[derive(PartialEq, PartialOrd)]` + // to the `TestDeriveOnAlias` new-type alias. If it didn't, this will fail to compile. + let test1 = unsafe { bindings::TestDeriveOnAlias(5) }; + let test2 = unsafe { bindings::TestDeriveOnAlias(6) }; + assert!(test1 < test2); + assert!(!(test1 > test2)); +} + +#[test] +fn test_custom_attributes() { + // The `add_attributes` callback should have added `#[cfg_attr(test, derive(PartialOrd))])` + // to the `Test` struct. If it didn't, this will fail to compile. + let test1 = unsafe { bindings::Test::new(5) }; + let test2 = unsafe { bindings::Test::new(6) }; + assert!(test1 < test2); +} + +#[test] +fn test_wrap_static_fns() { + // GH-1090: https://github.com/rust-lang/rust-bindgen/issues/1090 + unsafe { + let f = extern_bindings::foo(); + assert_eq!(11, f); + + let b = extern_bindings::bar(); + assert_eq!(1, b); + + let t = extern_bindings::takes_ptr(&mut 1); + assert_eq!(2, t); + + extern "C" fn function(x: i32) -> i32 { + x + 1 + } + + let tp = extern_bindings::takes_fn_ptr(Some(function)); + assert_eq!(2, tp); + + let tf = extern_bindings::takes_fn(Some(function)); + assert_eq!(3, tf); + + let ta = extern_bindings::takes_alias(Some(function)); + assert_eq!(4, ta); + + let tq = + extern_bindings::takes_qualified(&(&5 as *const _) as *const _); + assert_eq!(5, tq); + + // aarch64-linux has a bug, enable again when it is solved: + // https://github.com/rust-lang/rust-bindgen/issues/3234 + #[cfg(not(all(target_arch = "aarch64", target_os = "linux")))] + { + let wv1 = extern_bindings::wrap_as_variadic_fn1_wrapped(0); + assert_eq!(0, wv1); + + let wv1 = extern_bindings::wrap_as_variadic_fn1_wrapped(2, 5, 3); + assert_eq!(8, wv1); + + extern_bindings::wrap_as_variadic_fn2_wrapped(1, 2); + } + } +} + +#[test] +fn test_colon_define() { + let gold: u32 = (1u32 << 16) | 2; + assert_eq!(gold, bindings::TESTMACRO_COLON_VALUE); +} + +#[test] +fn test_new_type_alias_const() { + assert_eq!(bindings::MY_INT.0, 5); + assert_eq!(bindings::MY_BOOL.0, true); + assert_eq!(bindings::MY_FLOAT.0, 1.23f32); + assert_eq!(bindings::MY_CHAR.0, b'a' as std::ffi::c_char); +} diff --git a/bindgen-tests/Cargo.toml b/bindgen-tests/Cargo.toml new file mode 100644 index 0000000000..77a28ca3cb --- /dev/null +++ b/bindgen-tests/Cargo.toml @@ -0,0 +1,28 @@ +lints.workspace = true + +[package] +name = "bindgen-tests" +version = "0.1.0" +publish = false +rust-version.workspace = true +edition.workspace = true + +[dev-dependencies] +bindgen = { workspace = true, default-features = true, features = ["__cli", "experimental"] } +owo-colors.workspace = true +prettyplease = { workspace = true, features = ["verbatim"] } +proc-macro2.workspace = true +regex.workspace = true +shlex.workspace = true +similar = { workspace = true, features = ["inline"] } +syn.workspace = true +tempfile.workspace = true + +[features] +logging = ["bindgen/logging"] +static = ["bindgen/static"] +runtime = ["bindgen/runtime"] + +__testing_only_extra_assertions = ["bindgen/__testing_only_extra_assertions"] +__testing_only_libclang_9 = ["bindgen/__testing_only_libclang_9"] +__testing_only_libclang_16 = ["bindgen/__testing_only_libclang_16"] diff --git a/bindgen-tests/build.rs b/bindgen-tests/build.rs new file mode 100644 index 0000000000..cf929b4b65 --- /dev/null +++ b/bindgen-tests/build.rs @@ -0,0 +1,44 @@ +use std::char; +use std::env; +use std::fs::{self, File}; +use std::io::Write; +use std::path::{Path, PathBuf}; + +pub fn main() { + let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap()); + let mut dst = File::create(Path::new(&out_dir).join("tests.rs")).unwrap(); + + let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap()); + let headers_dir = manifest_dir.join("tests").join("headers"); + + let Ok(headers) = fs::read_dir(headers_dir) else { + // We may not have headers directory after packaging. + return; + }; + + let entries = + headers.map(|result| result.expect("Couldn't read header file")); + + println!("cargo:rerun-if-changed=tests/headers"); + + for entry in entries { + // TODO: file_is_cpp() in bindgen/lib.rs checks for hpp,hxx,hh, and h++ - should this be consistent? + if entry.path().extension().is_some_and(|ext| { + ext.eq_ignore_ascii_case("h") || ext.eq_ignore_ascii_case("hpp") + }) { + let func = entry + .file_name() + .to_str() + .unwrap() + .replace(|c| !char::is_alphanumeric(c), "_") + .replace("__", "_") + .to_lowercase(); + // We actually want the quotes and escape + #[allow(clippy::unnecessary_debug_formatting)] + writeln!(dst, "test_header!(header_{func}, {:?});", entry.path()) + .unwrap(); + } + } + + dst.flush().unwrap(); +} diff --git a/bindgen-tests/src/lib.rs b/bindgen-tests/src/lib.rs new file mode 100644 index 0000000000..8b13789179 --- /dev/null +++ b/bindgen-tests/src/lib.rs @@ -0,0 +1 @@ + diff --git a/bindgen-tests/tests/.gitattributes b/bindgen-tests/tests/.gitattributes new file mode 100644 index 0000000000..96122eb1da --- /dev/null +++ b/bindgen-tests/tests/.gitattributes @@ -0,0 +1,4 @@ +# Tell Github Linguist to avoid counting these C and C++ test inputs toward +# statistics. +*.h -linguist-detectable +*.hpp -linguist-detectable diff --git a/bindgen-tests/tests/expectations/Cargo.toml b/bindgen-tests/tests/expectations/Cargo.toml new file mode 100644 index 0000000000..975fd16678 --- /dev/null +++ b/bindgen-tests/tests/expectations/Cargo.toml @@ -0,0 +1,46 @@ +[package] +name = "tests_expectations" +description = "bindgen results when ran on ../headers/*" +version = "0.0.0" +authors = [ + "Jyun-Yan You ", + "Emilio Cobos Álvarez ", + "The Servo project developers", +] +publish = false +rust-version.workspace = true +edition.workspace = true + +[dependencies] +block.workspace = true +libloading.workspace = true +objc.workspace = true + +# Both of these sections need to be copied here from the workspace because +# Cargo currently does not allow overriding workspace settings in a member +[lints.rust] +### FIXME: these might need to be fixed, +### esp the calling convention, because it is a hard error now +# deprecated = "allow" +# invalid-value = "allow" +# unsupported_calling_conventions = "allow" +# +# Different from the workspace +dead_code = "allow" +non-snake-case = "allow" +non_camel_case_types = "allow" +non_upper_case_globals = "allow" +unexpected-cfgs = "allow" +unused_qualifications = "allow" + +[lints.clippy] +disallowed-names = "allow" +manual-c-str-literals = "allow" +missing-safety-doc = "allow" +op-ref = "allow" +ptr-offset-with-cast = "allow" +semicolon_if_nothing_returned = "allow" +too-many-arguments = "allow" +transmute-int-to-bool = "allow" +unnecessary-cast = "allow" +useless-transmute = "allow" diff --git a/bindgen-tests/tests/expectations/build.rs b/bindgen-tests/tests/expectations/build.rs new file mode 100644 index 0000000000..f4ded7e12d --- /dev/null +++ b/bindgen-tests/tests/expectations/build.rs @@ -0,0 +1,61 @@ +//! Generate a module with a custom `#[path=...]` for each of the files in our +//! libclang version-specific test expectations so that they get their layout +//! tests run. We need to do this because cargo doesn't automatically detect +//! tests subdirectories. + +use std::env; +use std::fs; +use std::io::Write; +use std::path::Path; + +const LIBCLANG_VERSION_DIRS: &[&str] = &["libclang-9"]; + +fn main() { + println!("cargo:rerun-if-changed=build.rs"); + + let mut test_string = String::new(); + + for dir in LIBCLANG_VERSION_DIRS { + let dir = Path::new(&env::var_os("CARGO_MANIFEST_DIR").unwrap()) + .join("tests") + .join(dir); + + println!("cargo:rerun-if-changed={}", dir.display()); + + for entry in fs::read_dir(dir).unwrap() { + let entry = entry.unwrap(); + let path = entry.path(); + let path = path.canonicalize().unwrap_or(path); + if path.extension().map(|e| e.to_string_lossy()) != + Some("rs".into()) + { + continue; + } + + println!("cargo:rerun-if-changed={}", path.display()); + + let module_name: String = path + .display() + .to_string() + .chars() + .map(|c| match c { + 'a'..='z' | 'A'..='Z' | '0'..='9' => c, + _ => '_', + }) + .collect(); + + test_string.push_str(&format!( + r###" +#[path = "{}"] +mod {module_name}; +"###, + path.display().to_string().replace('\\', "\\\\"), + )); + } + } + + let out_path = Path::new(&env::var_os("OUT_DIR").unwrap()) + .join("libclang_version_specific_generated_tests.rs"); + let mut test_file = fs::File::create(out_path).unwrap(); + test_file.write_all(test_string.as_bytes()).unwrap(); +} diff --git a/bindgen-tests/tests/expectations/lib.rs b/bindgen-tests/tests/expectations/lib.rs new file mode 100755 index 0000000000..e69de29bb2 diff --git a/bindgen-tests/tests/expectations/rustfmt.toml b/bindgen-tests/tests/expectations/rustfmt.toml new file mode 100644 index 0000000000..85a7173599 --- /dev/null +++ b/bindgen-tests/tests/expectations/rustfmt.toml @@ -0,0 +1,2 @@ +# disable rustfmt for this crate so running `cargo fmt` doesn't affect the expected binding files +disable_all_formatting = true diff --git a/bindgen-tests/tests/expectations/src/lib.rs b/bindgen-tests/tests/expectations/src/lib.rs new file mode 100644 index 0000000000..8b13789179 --- /dev/null +++ b/bindgen-tests/tests/expectations/src/lib.rs @@ -0,0 +1 @@ + diff --git a/bindgen-tests/tests/expectations/struct_with_anon_struct_array_float.rs b/bindgen-tests/tests/expectations/struct_with_anon_struct_array_float.rs new file mode 100644 index 0000000000..8b13789179 --- /dev/null +++ b/bindgen-tests/tests/expectations/struct_with_anon_struct_array_float.rs @@ -0,0 +1 @@ + diff --git a/bindgen-tests/tests/expectations/tests/.gitattributes b/bindgen-tests/tests/expectations/tests/.gitattributes new file mode 100644 index 0000000000..9699dfa001 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/.gitattributes @@ -0,0 +1,2 @@ +# Prevent Github Linguist from counting generated files in statistics. +*.rs linguist-generated diff --git a/bindgen-tests/tests/expectations/tests/16-byte-alignment.rs b/bindgen-tests/tests/expectations/tests/16-byte-alignment.rs new file mode 100644 index 0000000000..c55d0b075b --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/16-byte-alignment.rs @@ -0,0 +1,184 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct rte_ipv4_tuple { + pub src_addr: u32, + pub dst_addr: u32, + pub __bindgen_anon_1: rte_ipv4_tuple__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union rte_ipv4_tuple__bindgen_ty_1 { + pub __bindgen_anon_1: rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1, + pub sctp_tag: u32, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1 { + pub dport: u16, + pub sport: u16, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1", + ][::std::mem::align_of::() - 2usize]; + [ + "Offset of field: rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1::dport", + ][::std::mem::offset_of!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1, dport) + - 0usize]; + [ + "Offset of field: rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1::sport", + ][::std::mem::offset_of!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1, sport) + - 2usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_ipv4_tuple__bindgen_ty_1", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of rte_ipv4_tuple__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_ipv4_tuple__bindgen_ty_1::sctp_tag", + ][::std::mem::offset_of!(rte_ipv4_tuple__bindgen_ty_1, sctp_tag) - 0usize]; +}; +impl Default for rte_ipv4_tuple__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_ipv4_tuple"][::std::mem::size_of::() - 12usize]; + ["Alignment of rte_ipv4_tuple"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_ipv4_tuple::src_addr", + ][::std::mem::offset_of!(rte_ipv4_tuple, src_addr) - 0usize]; + [ + "Offset of field: rte_ipv4_tuple::dst_addr", + ][::std::mem::offset_of!(rte_ipv4_tuple, dst_addr) - 4usize]; +}; +impl Default for rte_ipv4_tuple { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct rte_ipv6_tuple { + pub src_addr: [u8; 16usize], + pub dst_addr: [u8; 16usize], + pub __bindgen_anon_1: rte_ipv6_tuple__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union rte_ipv6_tuple__bindgen_ty_1 { + pub __bindgen_anon_1: rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1, + pub sctp_tag: u32, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1 { + pub dport: u16, + pub sport: u16, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1", + ][::std::mem::align_of::() - 2usize]; + [ + "Offset of field: rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1::dport", + ][::std::mem::offset_of!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1, dport) + - 0usize]; + [ + "Offset of field: rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1::sport", + ][::std::mem::offset_of!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1, sport) + - 2usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_ipv6_tuple__bindgen_ty_1", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of rte_ipv6_tuple__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_ipv6_tuple__bindgen_ty_1::sctp_tag", + ][::std::mem::offset_of!(rte_ipv6_tuple__bindgen_ty_1, sctp_tag) - 0usize]; +}; +impl Default for rte_ipv6_tuple__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_ipv6_tuple"][::std::mem::size_of::() - 36usize]; + ["Alignment of rte_ipv6_tuple"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_ipv6_tuple::src_addr", + ][::std::mem::offset_of!(rte_ipv6_tuple, src_addr) - 0usize]; + [ + "Offset of field: rte_ipv6_tuple::dst_addr", + ][::std::mem::offset_of!(rte_ipv6_tuple, dst_addr) - 16usize]; +}; +impl Default for rte_ipv6_tuple { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub union rte_thash_tuple { + pub v4: rte_ipv4_tuple, + pub v6: rte_ipv6_tuple, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_thash_tuple"][::std::mem::size_of::() - 48usize]; + [ + "Alignment of rte_thash_tuple", + ][::std::mem::align_of::() - 16usize]; + [ + "Offset of field: rte_thash_tuple::v4", + ][::std::mem::offset_of!(rte_thash_tuple, v4) - 0usize]; + [ + "Offset of field: rte_thash_tuple::v6", + ][::std::mem::offset_of!(rte_thash_tuple, v6) - 0usize]; +}; +impl Default for rte_thash_tuple { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/381-decltype-alias.rs b/bindgen-tests/tests/expectations/tests/381-decltype-alias.rs new file mode 100644 index 0000000000..ed893c21df --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/381-decltype-alias.rs @@ -0,0 +1,7 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct std_allocator_traits { + pub _address: u8, +} +pub type std_allocator_traits___size_type<_Alloc> = _Alloc; diff --git a/bindgen-tests/tests/expectations/tests/abi-override.rs b/bindgen-tests/tests/expectations/tests/abi-override.rs new file mode 100644 index 0000000000..369bfd8d32 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/abi-override.rs @@ -0,0 +1,16 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target = "i686-pc-windows-msvc")] +unsafe extern "fastcall" { + pub fn foo(); +} +unsafe extern "stdcall" { + pub fn bar(); +} +unsafe extern "C" { + pub fn baz(); +} +unsafe extern "system" { + pub fn qux(); +} +pub type boo = ::std::option::Option; +pub type foobar = ::std::option::Option; diff --git a/bindgen-tests/tests/expectations/tests/abi_variadic_function.rs b/bindgen-tests/tests/expectations/tests/abi_variadic_function.rs new file mode 100644 index 0000000000..b57ddafd32 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/abi_variadic_function.rs @@ -0,0 +1,5 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + #[link_name = "\u{1}_Z1bcz"] + pub fn b(arg1: ::std::os::raw::c_char, ...) -> ::std::os::raw::c_char; +} diff --git a/bindgen-tests/tests/expectations/tests/accessors.rs b/bindgen-tests/tests/expectations/tests/accessors.rs new file mode 100644 index 0000000000..586edf2d79 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/accessors.rs @@ -0,0 +1,228 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct SomeAccessors { + pub mNoAccessor: ::std::os::raw::c_int, + ///
+ pub mBothAccessors: ::std::os::raw::c_int, + ///
+ pub mUnsafeAccessors: ::std::os::raw::c_int, + ///
+ pub mImmutableAccessor: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of SomeAccessors"][::std::mem::size_of::() - 16usize]; + ["Alignment of SomeAccessors"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: SomeAccessors::mNoAccessor", + ][::std::mem::offset_of!(SomeAccessors, mNoAccessor) - 0usize]; + [ + "Offset of field: SomeAccessors::mBothAccessors", + ][::std::mem::offset_of!(SomeAccessors, mBothAccessors) - 4usize]; + [ + "Offset of field: SomeAccessors::mUnsafeAccessors", + ][::std::mem::offset_of!(SomeAccessors, mUnsafeAccessors) - 8usize]; + [ + "Offset of field: SomeAccessors::mImmutableAccessor", + ][::std::mem::offset_of!(SomeAccessors, mImmutableAccessor) - 12usize]; +}; +impl SomeAccessors { + #[inline] + pub fn get_mBothAccessors(&self) -> &::std::os::raw::c_int { + &self.mBothAccessors + } + #[inline] + pub fn get_mBothAccessors_mut(&mut self) -> &mut ::std::os::raw::c_int { + &mut self.mBothAccessors + } + #[inline] + pub unsafe fn get_mUnsafeAccessors(&self) -> &::std::os::raw::c_int { + &self.mUnsafeAccessors + } + #[inline] + pub unsafe fn get_mUnsafeAccessors_mut(&mut self) -> &mut ::std::os::raw::c_int { + &mut self.mUnsafeAccessors + } + #[inline] + pub fn get_mImmutableAccessor(&self) -> &::std::os::raw::c_int { + &self.mImmutableAccessor + } +} +///
+#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct AllAccessors { + pub mBothAccessors: ::std::os::raw::c_int, + pub mAlsoBothAccessors: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of AllAccessors"][::std::mem::size_of::() - 8usize]; + ["Alignment of AllAccessors"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: AllAccessors::mBothAccessors", + ][::std::mem::offset_of!(AllAccessors, mBothAccessors) - 0usize]; + [ + "Offset of field: AllAccessors::mAlsoBothAccessors", + ][::std::mem::offset_of!(AllAccessors, mAlsoBothAccessors) - 4usize]; +}; +impl AllAccessors { + #[inline] + pub fn get_mBothAccessors(&self) -> &::std::os::raw::c_int { + &self.mBothAccessors + } + #[inline] + pub fn get_mBothAccessors_mut(&mut self) -> &mut ::std::os::raw::c_int { + &mut self.mBothAccessors + } + #[inline] + pub fn get_mAlsoBothAccessors(&self) -> &::std::os::raw::c_int { + &self.mAlsoBothAccessors + } + #[inline] + pub fn get_mAlsoBothAccessors_mut(&mut self) -> &mut ::std::os::raw::c_int { + &mut self.mAlsoBothAccessors + } +} +///
+#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct AllUnsafeAccessors { + pub mBothAccessors: ::std::os::raw::c_int, + pub mAlsoBothAccessors: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of AllUnsafeAccessors"][::std::mem::size_of::() - 8usize]; + [ + "Alignment of AllUnsafeAccessors", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: AllUnsafeAccessors::mBothAccessors", + ][::std::mem::offset_of!(AllUnsafeAccessors, mBothAccessors) - 0usize]; + [ + "Offset of field: AllUnsafeAccessors::mAlsoBothAccessors", + ][::std::mem::offset_of!(AllUnsafeAccessors, mAlsoBothAccessors) - 4usize]; +}; +impl AllUnsafeAccessors { + #[inline] + pub unsafe fn get_mBothAccessors(&self) -> &::std::os::raw::c_int { + &self.mBothAccessors + } + #[inline] + pub unsafe fn get_mBothAccessors_mut(&mut self) -> &mut ::std::os::raw::c_int { + &mut self.mBothAccessors + } + #[inline] + pub unsafe fn get_mAlsoBothAccessors(&self) -> &::std::os::raw::c_int { + &self.mAlsoBothAccessors + } + #[inline] + pub unsafe fn get_mAlsoBothAccessors_mut(&mut self) -> &mut ::std::os::raw::c_int { + &mut self.mAlsoBothAccessors + } +} +///
+#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct ContradictAccessors { + pub mBothAccessors: ::std::os::raw::c_int, + ///
+ pub mNoAccessors: ::std::os::raw::c_int, + ///
+ pub mUnsafeAccessors: ::std::os::raw::c_int, + ///
+ pub mImmutableAccessor: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of ContradictAccessors", + ][::std::mem::size_of::() - 16usize]; + [ + "Alignment of ContradictAccessors", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: ContradictAccessors::mBothAccessors", + ][::std::mem::offset_of!(ContradictAccessors, mBothAccessors) - 0usize]; + [ + "Offset of field: ContradictAccessors::mNoAccessors", + ][::std::mem::offset_of!(ContradictAccessors, mNoAccessors) - 4usize]; + [ + "Offset of field: ContradictAccessors::mUnsafeAccessors", + ][::std::mem::offset_of!(ContradictAccessors, mUnsafeAccessors) - 8usize]; + [ + "Offset of field: ContradictAccessors::mImmutableAccessor", + ][::std::mem::offset_of!(ContradictAccessors, mImmutableAccessor) - 12usize]; +}; +impl ContradictAccessors { + #[inline] + pub fn get_mBothAccessors(&self) -> &::std::os::raw::c_int { + &self.mBothAccessors + } + #[inline] + pub fn get_mBothAccessors_mut(&mut self) -> &mut ::std::os::raw::c_int { + &mut self.mBothAccessors + } + #[inline] + pub unsafe fn get_mUnsafeAccessors(&self) -> &::std::os::raw::c_int { + &self.mUnsafeAccessors + } + #[inline] + pub unsafe fn get_mUnsafeAccessors_mut(&mut self) -> &mut ::std::os::raw::c_int { + &mut self.mUnsafeAccessors + } + #[inline] + pub fn get_mImmutableAccessor(&self) -> &::std::os::raw::c_int { + &self.mImmutableAccessor + } +} +///
+#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Replaced { + pub mAccessor: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Replaced"][::std::mem::size_of::() - 4usize]; + ["Alignment of Replaced"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: Replaced::mAccessor", + ][::std::mem::offset_of!(Replaced, mAccessor) - 0usize]; +}; +impl Replaced { + #[inline] + pub fn get_mAccessor(&self) -> &::std::os::raw::c_int { + &self.mAccessor + } + #[inline] + pub fn get_mAccessor_mut(&mut self) -> &mut ::std::os::raw::c_int { + &mut self.mAccessor + } +} +///
+#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Wrapper { + pub mReplaced: Replaced, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Wrapper"][::std::mem::size_of::() - 4usize]; + ["Alignment of Wrapper"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: Wrapper::mReplaced", + ][::std::mem::offset_of!(Wrapper, mReplaced) - 0usize]; +}; +impl Wrapper { + #[inline] + pub fn get_mReplaced(&self) -> &Replaced { + &self.mReplaced + } + #[inline] + pub fn get_mReplaced_mut(&mut self) -> &mut Replaced { + &mut self.mReplaced + } +} diff --git a/bindgen-tests/tests/expectations/tests/alias_comments.rs b/bindgen-tests/tests/expectations/tests/alias_comments.rs new file mode 100644 index 0000000000..31ff72b2c6 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/alias_comments.rs @@ -0,0 +1,14 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +/// This is Struct +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Struct { + /// This is field + pub field: ::std::os::raw::c_int, +} +/// This is AliasToStruct +pub type AliasToStruct = Struct; +/// This is AliasToInt +pub type AliasToInt = ::std::os::raw::c_int; +/// This is AliasToAliasToInt +pub type AliasToAliasToInt = AliasToInt; diff --git a/bindgen-tests/tests/expectations/tests/allowlist-file.rs b/bindgen-tests/tests/expectations/tests/allowlist-file.rs new file mode 100644 index 0000000000..b1fb170de0 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/allowlist-file.rs @@ -0,0 +1,92 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const SOME_DEFUN: u32 = 123; +unsafe extern "C" { + #[link_name = "\u{1}_Z12SomeFunctionv"] + pub fn SomeFunction(); +} +unsafe extern "C" { + pub static mut someVar: ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct someClass { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of someClass"][::std::mem::size_of::() - 1usize]; + ["Alignment of someClass"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN9someClass16somePublicMethodEi"] + pub fn someClass_somePublicMethod(this: *mut someClass, foo: ::std::os::raw::c_int); +} +impl someClass { + #[inline] + pub unsafe fn somePublicMethod(&mut self, foo: ::std::os::raw::c_int) { + someClass_somePublicMethod(self, foo) + } +} +unsafe extern "C" { + pub fn ExternFunction(); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN3foo18NamespacedFunctionEv"] + pub fn foo_NamespacedFunction(); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StructWithAllowlistedDefinition { + pub other: *mut StructWithAllowlistedFwdDecl, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of StructWithAllowlistedDefinition", + ][::std::mem::size_of::() - 8usize]; + [ + "Alignment of StructWithAllowlistedDefinition", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: StructWithAllowlistedDefinition::other", + ][::std::mem::offset_of!(StructWithAllowlistedDefinition, other) - 0usize]; +}; +impl Default for StructWithAllowlistedDefinition { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct StructWithAllowlistedFwdDecl { + pub b: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of StructWithAllowlistedFwdDecl", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of StructWithAllowlistedFwdDecl", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: StructWithAllowlistedFwdDecl::b", + ][::std::mem::offset_of!(StructWithAllowlistedFwdDecl, b) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct AllowlistMe { + pub foo: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of AllowlistMe"][::std::mem::size_of::() - 4usize]; + ["Alignment of AllowlistMe"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: AllowlistMe::foo", + ][::std::mem::offset_of!(AllowlistMe, foo) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/allowlist-namespaces-basic.rs b/bindgen-tests/tests/expectations/tests/allowlist-namespaces-basic.rs new file mode 100644 index 0000000000..151d03f4a4 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/allowlist-namespaces-basic.rs @@ -0,0 +1,24 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod outer { + #[allow(unused_imports)] + use self::super::super::root; + pub mod inner { + #[allow(unused_imports)] + use self::super::super::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Helper { + pub _address: u8, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Helper"][::std::mem::size_of::() - 1usize]; + ["Alignment of Helper"][::std::mem::align_of::() - 1usize]; + }; + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/allowlist-namespaces.rs b/bindgen-tests/tests/expectations/tests/allowlist-namespaces.rs new file mode 100644 index 0000000000..563c97ca1d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/allowlist-namespaces.rs @@ -0,0 +1,37 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod outer { + #[allow(unused_imports)] + use self::super::super::root; + pub mod inner { + #[allow(unused_imports)] + use self::super::super::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Helper { + pub _address: u8, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Helper"][::std::mem::size_of::() - 1usize]; + ["Alignment of Helper"][::std::mem::align_of::() - 1usize]; + }; + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Test { + pub helper: root::outer::inner::Helper, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Test"][::std::mem::size_of::() - 1usize]; + ["Alignment of Test"][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: Test::helper", + ][::std::mem::offset_of!(Test, helper) - 0usize]; + }; + } +} diff --git a/bindgen-tests/tests/expectations/tests/allowlist_basic.rs b/bindgen-tests/tests/expectations/tests/allowlist_basic.rs new file mode 100644 index 0000000000..a1c6919739 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/allowlist_basic.rs @@ -0,0 +1,32 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct AllowlistMe { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub foo: ::std::os::raw::c_int, + pub bar: AllowlistMe_Inner, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct AllowlistMe_Inner { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub bar: T, +} +impl Default for AllowlistMe_Inner { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Default for AllowlistMe { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/allowlist_fix.rs b/bindgen-tests/tests/expectations/tests/allowlist_fix.rs new file mode 100644 index 0000000000..772772c56c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/allowlist_fix.rs @@ -0,0 +1,5 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub enum Test {} +unsafe extern "C" { + pub fn Servo_Test(a: *mut Test); +} diff --git a/bindgen-tests/tests/expectations/tests/allowlist_item.rs b/bindgen-tests/tests/expectations/tests/allowlist_item.rs new file mode 100644 index 0000000000..93eab7e147 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/allowlist_item.rs @@ -0,0 +1,16 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const FooDefault: u32 = 0; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub field: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Foo::field"][::std::mem::offset_of!(Foo, field) - 0usize]; +}; +unsafe extern "C" { + pub fn FooNew(value: ::std::os::raw::c_int) -> Foo; +} diff --git a/bindgen-tests/tests/expectations/tests/allowlist_vars.rs b/bindgen-tests/tests/expectations/tests/allowlist_vars.rs new file mode 100644 index 0000000000..342d904a73 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/allowlist_vars.rs @@ -0,0 +1,5 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const NONE: u32 = 0; +pub const FOO: u32 = 5; +pub const FOOB: i32 = -2; +pub const FOOBAR: i32 = -10; diff --git a/bindgen-tests/tests/expectations/tests/allowlist_warnings.rs b/bindgen-tests/tests/expectations/tests/allowlist_warnings.rs new file mode 100644 index 0000000000..fe64295a68 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/allowlist_warnings.rs @@ -0,0 +1 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] \ No newline at end of file diff --git a/bindgen-tests/tests/expectations/tests/allowlisted-item-references-no-hash.rs b/bindgen-tests/tests/expectations/tests/allowlisted-item-references-no-hash.rs new file mode 100644 index 0000000000..6c1d13a837 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/allowlisted-item-references-no-hash.rs @@ -0,0 +1,22 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct NoHash { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of NoHash"][::std::mem::size_of::() - 1usize]; + ["Alignment of NoHash"][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct AllowlistMe { + pub a: NoHash, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of AllowlistMe"][::std::mem::size_of::() - 1usize]; + ["Alignment of AllowlistMe"][::std::mem::align_of::() - 1usize]; + ["Offset of field: AllowlistMe::a"][::std::mem::offset_of!(AllowlistMe, a) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/allowlisted-item-references-no-partialeq.rs b/bindgen-tests/tests/expectations/tests/allowlisted-item-references-no-partialeq.rs new file mode 100644 index 0000000000..b969727dbb --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/allowlisted-item-references-no-partialeq.rs @@ -0,0 +1,22 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct NoPartialEq { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of NoPartialEq"][::std::mem::size_of::() - 1usize]; + ["Alignment of NoPartialEq"][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct AllowlistMe { + pub a: NoPartialEq, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of AllowlistMe"][::std::mem::size_of::() - 1usize]; + ["Alignment of AllowlistMe"][::std::mem::align_of::() - 1usize]; + ["Offset of field: AllowlistMe::a"][::std::mem::offset_of!(AllowlistMe, a) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/allowlisted_item_references_no_copy.rs b/bindgen-tests/tests/expectations/tests/allowlisted_item_references_no_copy.rs new file mode 100644 index 0000000000..8c671b4e84 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/allowlisted_item_references_no_copy.rs @@ -0,0 +1,22 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default)] +pub struct NoCopy { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of NoCopy"][::std::mem::size_of::() - 1usize]; + ["Alignment of NoCopy"][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Default)] +pub struct AllowlistMe { + pub a: NoCopy, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of AllowlistMe"][::std::mem::size_of::() - 1usize]; + ["Alignment of AllowlistMe"][::std::mem::align_of::() - 1usize]; + ["Offset of field: AllowlistMe::a"][::std::mem::offset_of!(AllowlistMe, a) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/annotation_hide.rs b/bindgen-tests/tests/expectations/tests/annotation_hide.rs new file mode 100644 index 0000000000..e79c88214d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/annotation_hide.rs @@ -0,0 +1,26 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +///
+#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Default, Copy, Clone)] +pub struct D { + pub _bindgen_opaque_blob: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of D"][::std::mem::size_of::() - 4usize]; + ["Alignment of D"][::std::mem::align_of::() - 4usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct NotAnnotated { + pub f: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of NotAnnotated"][::std::mem::size_of::() - 4usize]; + ["Alignment of NotAnnotated"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: NotAnnotated::f", + ][::std::mem::offset_of!(NotAnnotated, f) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/anon-fields-prefix.rs b/bindgen-tests/tests/expectations/tests/anon-fields-prefix.rs new file mode 100644 index 0000000000..2b96804c9b --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/anon-fields-prefix.rs @@ -0,0 +1,73 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone)] +pub union color { + pub u1: color__bindgen_ty_1, + pub u2: color__bindgen_ty_2, + pub v3: [::std::os::raw::c_uchar; 3usize], +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct color__bindgen_ty_1 { + pub r: ::std::os::raw::c_uchar, + pub g: ::std::os::raw::c_uchar, + pub b: ::std::os::raw::c_uchar, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of color__bindgen_ty_1", + ][::std::mem::size_of::() - 3usize]; + [ + "Alignment of color__bindgen_ty_1", + ][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: color__bindgen_ty_1::r", + ][::std::mem::offset_of!(color__bindgen_ty_1, r) - 0usize]; + [ + "Offset of field: color__bindgen_ty_1::g", + ][::std::mem::offset_of!(color__bindgen_ty_1, g) - 1usize]; + [ + "Offset of field: color__bindgen_ty_1::b", + ][::std::mem::offset_of!(color__bindgen_ty_1, b) - 2usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct color__bindgen_ty_2 { + pub y: ::std::os::raw::c_uchar, + pub u: ::std::os::raw::c_uchar, + pub v: ::std::os::raw::c_uchar, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of color__bindgen_ty_2", + ][::std::mem::size_of::() - 3usize]; + [ + "Alignment of color__bindgen_ty_2", + ][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: color__bindgen_ty_2::y", + ][::std::mem::offset_of!(color__bindgen_ty_2, y) - 0usize]; + [ + "Offset of field: color__bindgen_ty_2::u", + ][::std::mem::offset_of!(color__bindgen_ty_2, u) - 1usize]; + [ + "Offset of field: color__bindgen_ty_2::v", + ][::std::mem::offset_of!(color__bindgen_ty_2, v) - 2usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of color"][::std::mem::size_of::() - 3usize]; + ["Alignment of color"][::std::mem::align_of::() - 1usize]; + ["Offset of field: color::v3"][::std::mem::offset_of!(color, v3) - 0usize]; +}; +impl Default for color { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/anon_enum.rs b/bindgen-tests/tests/expectations/tests/anon_enum.rs new file mode 100644 index 0000000000..c3790a2a24 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/anon_enum.rs @@ -0,0 +1,26 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, PartialEq)] +pub struct Test { + pub foo: ::std::os::raw::c_int, + pub bar: f32, +} +pub const Test_T_NONE: Test__bindgen_ty_1 = Test__bindgen_ty_1::T_NONE; +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum Test__bindgen_ty_1 { + T_NONE = 0, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Test"][::std::mem::size_of::() - 8usize]; + ["Alignment of Test"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Test::foo"][::std::mem::offset_of!(Test, foo) - 0usize]; + ["Offset of field: Test::bar"][::std::mem::offset_of!(Test, bar) - 4usize]; +}; +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum Baz { + Foo = 0, + Bar = 1, +} diff --git a/bindgen-tests/tests/expectations/tests/anon_enum_allowlist.rs b/bindgen-tests/tests/expectations/tests/anon_enum_allowlist.rs new file mode 100644 index 0000000000..4b172d7aeb --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/anon_enum_allowlist.rs @@ -0,0 +1,9 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const NODE_FLAG_FOO: _bindgen_ty_1 = _bindgen_ty_1::NODE_FLAG_FOO; +pub const NODE_FLAG_BAR: _bindgen_ty_1 = _bindgen_ty_1::NODE_FLAG_BAR; +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _bindgen_ty_1 { + NODE_FLAG_FOO = 0, + NODE_FLAG_BAR = 1, +} diff --git a/bindgen-tests/tests/expectations/tests/anon_enum_allowlist_item.rs b/bindgen-tests/tests/expectations/tests/anon_enum_allowlist_item.rs new file mode 100644 index 0000000000..4d28c3abc7 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/anon_enum_allowlist_item.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const NODE_FLAG_FOO: _bindgen_ty_1 = 0; +pub const NODE_FLAG_BAR: _bindgen_ty_1 = 1; +pub type _bindgen_ty_1 = ::std::os::raw::c_uint; diff --git a/bindgen-tests/tests/expectations/tests/anon_enum_blocklist.rs b/bindgen-tests/tests/expectations/tests/anon_enum_blocklist.rs new file mode 100644 index 0000000000..28ab3ad786 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/anon_enum_blocklist.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const FLAG_Z: _bindgen_ty_2 = 0; +pub const FLAG_W: _bindgen_ty_2 = 1; +pub type _bindgen_ty_2 = ::std::os::raw::c_uint; diff --git a/bindgen-tests/tests/expectations/tests/anon_enum_trait.rs b/bindgen-tests/tests/expectations/tests/anon_enum_trait.rs new file mode 100644 index 0000000000..cfd4d03200 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/anon_enum_trait.rs @@ -0,0 +1,37 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct DataType { + pub _address: u8, +} +pub type DataType_value_type<_Tp> = _Tp; +pub type DataType_work_type<_Tp> = DataType_value_type<_Tp>; +pub type DataType_channel_type<_Tp> = DataType_value_type<_Tp>; +pub type DataType_vec_type<_Tp> = DataType_value_type<_Tp>; +pub const DataType_generic_type: DataType__bindgen_ty_1 = DataType__bindgen_ty_1::generic_type; +pub const DataType_depth: DataType__bindgen_ty_1 = DataType__bindgen_ty_1::generic_type; +pub const DataType_channels: DataType__bindgen_ty_1 = DataType__bindgen_ty_1::generic_type; +pub const DataType_fmt: DataType__bindgen_ty_1 = DataType__bindgen_ty_1::generic_type; +pub const DataType_type_: DataType__bindgen_ty_1 = DataType__bindgen_ty_1::generic_type; +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum DataType__bindgen_ty_1 { + generic_type = 0, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Foo { + pub _address: u8, +} +pub const Foo_Bar: Foo__bindgen_ty_1 = Foo__bindgen_ty_1::Bar; +pub const Foo_Baz: Foo__bindgen_ty_1 = Foo__bindgen_ty_1::Bar; +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum Foo__bindgen_ty_1 { + Bar = 0, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/anon_struct_in_union.rs b/bindgen-tests/tests/expectations/tests/anon_struct_in_union.rs new file mode 100644 index 0000000000..dceca1adf3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/anon_struct_in_union.rs @@ -0,0 +1,60 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct s { + pub u: s__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union s__bindgen_ty_1 { + pub field: s__bindgen_ty_1_inner, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct s__bindgen_ty_1_inner { + pub b: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of s__bindgen_ty_1_inner", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of s__bindgen_ty_1_inner", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: s__bindgen_ty_1_inner::b", + ][::std::mem::offset_of!(s__bindgen_ty_1_inner, b) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of s__bindgen_ty_1"][::std::mem::size_of::() - 4usize]; + ["Alignment of s__bindgen_ty_1"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: s__bindgen_ty_1::field", + ][::std::mem::offset_of!(s__bindgen_ty_1, field) - 0usize]; +}; +impl Default for s__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of s"][::std::mem::size_of::() - 4usize]; + ["Alignment of s"][::std::mem::align_of::() - 4usize]; + ["Offset of field: s::u"][::std::mem::offset_of!(s, u) - 0usize]; +}; +impl Default for s { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/anon_union.rs b/bindgen-tests/tests/expectations/tests/anon_union.rs new file mode 100644 index 0000000000..d9bf3cf183 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/anon_union.rs @@ -0,0 +1,76 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct TErrorResult { + pub mResult: ::std::os::raw::c_int, + pub __bindgen_anon_1: TErrorResult__bindgen_ty_1, + pub mMightHaveUnreported: bool, + pub mUnionState: TErrorResult_UnionState, +} +impl TErrorResult_UnionState { + pub const HasException: TErrorResult_UnionState = TErrorResult_UnionState::HasMessage; +} +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum TErrorResult_UnionState { + HasMessage = 0, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct TErrorResult_Message { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct TErrorResult_DOMExceptionInfo { + _unused: [u8; 0], +} +#[repr(C)] +pub union TErrorResult__bindgen_ty_1 { + pub mMessage: *mut TErrorResult_Message, + pub mDOMExceptionInfo: *mut TErrorResult_DOMExceptionInfo, +} +impl Default for TErrorResult__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Default for TErrorResult { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +pub struct ErrorResult { + pub _base: TErrorResult, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ErrorResult"][::std::mem::size_of::() - 24usize]; + ["Alignment of ErrorResult"][::std::mem::align_of::() - 8usize]; +}; +impl Default for ErrorResult { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: TErrorResult_open0_int_close0", + ][::std::mem::size_of::() - 24usize]; + [ + "Align of template specialization: TErrorResult_open0_int_close0", + ][::std::mem::align_of::() - 8usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/anonymous-template-types.rs b/bindgen-tests/tests/expectations/tests/anonymous-template-types.rs new file mode 100644 index 0000000000..f6c894d8b5 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/anonymous-template-types.rs @@ -0,0 +1,42 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Foo { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub t_member: T, +} +impl Default for Foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Bar { + pub member: ::std::os::raw::c_char, +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Quux { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub v_member: V, +} +impl Default for Quux { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Lobo { + pub also_member: ::std::os::raw::c_char, +} +pub type AliasWithAnonType = ::std::os::raw::c_char; diff --git a/bindgen-tests/tests/expectations/tests/arg_keyword.rs b/bindgen-tests/tests/expectations/tests/arg_keyword.rs new file mode 100644 index 0000000000..5a48aba011 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/arg_keyword.rs @@ -0,0 +1,5 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + #[link_name = "\u{1}_Z3fooPKc"] + pub fn foo(type_: *const ::std::os::raw::c_char); +} diff --git a/bindgen-tests/tests/expectations/tests/array-of-zero-sized-types.rs b/bindgen-tests/tests/expectations/tests/array-of-zero-sized-types.rs new file mode 100644 index 0000000000..4630abd275 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/array-of-zero-sized-types.rs @@ -0,0 +1,27 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +/// This should get an `_address` byte. +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Empty { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Empty"][::std::mem::size_of::() - 1usize]; + ["Alignment of Empty"][::std::mem::align_of::() - 1usize]; +}; +/** This should not get an `_address` byte, since each `Empty` gets one, meaning + that this object is addressable.*/ +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct HasArrayOfEmpty { + pub empties: [Empty; 10usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of HasArrayOfEmpty"][::std::mem::size_of::() - 10usize]; + ["Alignment of HasArrayOfEmpty"][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: HasArrayOfEmpty::empties", + ][::std::mem::offset_of!(HasArrayOfEmpty, empties) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/atomic-constant.rs b/bindgen-tests/tests/expectations/tests/atomic-constant.rs new file mode 100644 index 0000000000..344e632085 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/atomic-constant.rs @@ -0,0 +1,7 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub static mut a: ::std::os::raw::c_int; +} +unsafe extern "C" { + pub static mut b: ::std::os::raw::c_int; +} diff --git a/bindgen-tests/tests/expectations/tests/attribute-custom-cli.rs b/bindgen-tests/tests/expectations/tests/attribute-custom-cli.rs new file mode 100644 index 0000000000..55353116d3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/attribute-custom-cli.rs @@ -0,0 +1,48 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[doc(hidden)] +#[derive(Default)] +pub struct foo_struct { + pub inner: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo_struct"][::std::mem::size_of::() - 4usize]; + ["Alignment of foo_struct"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: foo_struct::inner", + ][::std::mem::offset_of!(foo_struct, inner) - 0usize]; +}; +#[repr(u32)] +#[cfg_attr(test, derive(PartialOrd, Copy))] +#[derive(Clone, Hash, PartialEq, Eq)] +pub enum foo_enum { + inner = 0, +} +#[repr(C)] +#[doc(hidden)] +#[derive(Clone)] +#[derive(Copy)] +pub union foo_union { + pub fst: ::std::mem::ManuallyDrop<::std::os::raw::c_int>, + pub snd: ::std::mem::ManuallyDrop, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo_union"][::std::mem::size_of::() - 4usize]; + ["Alignment of foo_union"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo_union::fst"][::std::mem::offset_of!(foo_union, fst) - 0usize]; + ["Offset of field: foo_union::snd"][::std::mem::offset_of!(foo_union, snd) - 0usize]; +}; +#[repr(C)] +pub struct non_matching { + pub inner: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of non_matching"][::std::mem::size_of::() - 4usize]; + ["Alignment of non_matching"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: non_matching::inner", + ][::std::mem::offset_of!(non_matching, inner) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/attribute-custom.rs b/bindgen-tests/tests/expectations/tests/attribute-custom.rs new file mode 100644 index 0000000000..6d616d3f3e --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/attribute-custom.rs @@ -0,0 +1,22 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +///
+#[repr(C)] +#[derive(Debug)] +pub struct my_type { + pub a: ::std::os::raw::c_int, +} +/**
+
*/ +#[repr(C)] +#[derive(Debug)] +#[derive(Clone)] +pub struct my_type2 { + pub a: ::std::os::raw::c_uint, +} +///
+#[repr(C)] +#[derive(Debug)] +#[derive(Clone)] +pub struct my_type3 { + pub a: ::std::os::raw::c_ulong, +} diff --git a/bindgen-tests/tests/expectations/tests/attribute_warn_unused_result.rs b/bindgen-tests/tests/expectations/tests/attribute_warn_unused_result.rs new file mode 100644 index 0000000000..ec152e1543 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/attribute_warn_unused_result.rs @@ -0,0 +1,28 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[must_use] + #[link_name = "\u{1}_ZN3Foo3fooEi"] + pub fn Foo_foo(this: *mut Foo, arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +impl Foo { + #[inline] + #[must_use] + pub unsafe fn foo(&mut self, arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + Foo_foo(self, arg1) + } +} +unsafe extern "C" { + #[must_use] + #[link_name = "\u{1}_Z3fooi"] + pub fn foo(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} diff --git a/bindgen-tests/tests/expectations/tests/attribute_warn_unused_result_no_attribute_detection.rs b/bindgen-tests/tests/expectations/tests/attribute_warn_unused_result_no_attribute_detection.rs new file mode 100644 index 0000000000..f0fb434bcb --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/attribute_warn_unused_result_no_attribute_detection.rs @@ -0,0 +1,25 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN3Foo3fooEi"] + pub fn Foo_foo(this: *mut Foo, arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +impl Foo { + #[inline] + pub unsafe fn foo(&mut self, arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + Foo_foo(self, arg1) + } +} +unsafe extern "C" { + #[link_name = "\u{1}_Z3fooi"] + pub fn foo(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} diff --git a/bindgen-tests/tests/expectations/tests/auto.rs b/bindgen-tests/tests/expectations/tests/auto.rs new file mode 100644 index 0000000000..ba93e7a20b --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/auto.rs @@ -0,0 +1,21 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +pub const Foo_kFoo: bool = true; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Bar { + pub _address: u8, +} +unsafe extern "C" { + #[link_name = "\u{1}_Z5Test2v"] + pub fn Test2() -> ::std::os::raw::c_uint; +} diff --git a/bindgen-tests/tests/expectations/tests/bad-namespace-parenthood-inheritance.rs b/bindgen-tests/tests/expectations/tests/bad-namespace-parenthood-inheritance.rs new file mode 100644 index 0000000000..9ad8429e3c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/bad-namespace-parenthood-inheritance.rs @@ -0,0 +1,20 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct std_char_traits { + pub _address: u8, +} +impl Default for std_char_traits { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct __gnu_cxx_char_traits { + pub _address: u8, +} diff --git a/bindgen-tests/tests/expectations/tests/base-to-derived.rs b/bindgen-tests/tests/expectations/tests/base-to-derived.rs new file mode 100644 index 0000000000..22ef4fdb08 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/base-to-derived.rs @@ -0,0 +1,11 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct false_type { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of false_type"][::std::mem::size_of::() - 1usize]; + ["Alignment of false_type"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/bindgen-union-inside-namespace.rs b/bindgen-tests/tests/expectations/tests/bindgen-union-inside-namespace.rs new file mode 100644 index 0000000000..2c8d2e5713 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/bindgen-union-inside-namespace.rs @@ -0,0 +1,32 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod foo { + #[allow(unused_imports)] + use self::super::super::root; + #[repr(C)] + #[derive(Copy, Clone)] + pub union Bar { + pub foo: ::std::os::raw::c_int, + pub bar: ::std::os::raw::c_int, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 4usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Bar::foo"][::std::mem::offset_of!(Bar, foo) - 0usize]; + ["Offset of field: Bar::bar"][::std::mem::offset_of!(Bar, bar) - 0usize]; + }; + impl Default for Bar { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/bitfield-32bit-overflow.rs b/bindgen-tests/tests/expectations/tests/bitfield-32bit-overflow.rs new file mode 100644 index 0000000000..783f0ef7a9 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/bitfield-32bit-overflow.rs @@ -0,0 +1,1673 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct MuchBitfield { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 5usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of MuchBitfield"][::std::mem::size_of::() - 5usize]; + ["Alignment of MuchBitfield"][::std::mem::align_of::() - 1usize]; +}; +impl MuchBitfield { + #[inline] + pub fn m0(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_m0(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m0_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_m0_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m1(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } + } + #[inline] + pub fn set_m1(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m1_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_m1_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m2(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) } + } + #[inline] + pub fn set_m2(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m2_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_m2_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m3(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) } + } + #[inline] + pub fn set_m3(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m3_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 3usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_m3_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m4(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) } + } + #[inline] + pub fn set_m4(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m4_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_m4_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m5(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) } + } + #[inline] + pub fn set_m5(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m5_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 5usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_m5_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m6(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) } + } + #[inline] + pub fn set_m6(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m6_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 6usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_m6_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m7(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) } + } + #[inline] + pub fn set_m7(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m7_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 7usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_m7_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m8(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u8) } + } + #[inline] + pub fn set_m8(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m8_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 8usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_m8_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m9(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u8) } + } + #[inline] + pub fn set_m9(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m9_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 9usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_m9_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 9usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m10(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u8) } + } + #[inline] + pub fn set_m10(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m10_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 10usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m10_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 10usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m11(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u8) } + } + #[inline] + pub fn set_m11(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m11_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 11usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m11_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m12(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u8) } + } + #[inline] + pub fn set_m12(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m12_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 12usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m12_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 12usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m13(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u8) } + } + #[inline] + pub fn set_m13(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m13_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 13usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m13_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 13usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m14(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u8) } + } + #[inline] + pub fn set_m14(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m14_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 14usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m14_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m15(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u8) } + } + #[inline] + pub fn set_m15(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m15_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 15usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m15_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 15usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m16(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u8) } + } + #[inline] + pub fn set_m16(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m16_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 16usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m16_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m17(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u8) } + } + #[inline] + pub fn set_m17(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m17_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 17usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m17_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m18(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u8) } + } + #[inline] + pub fn set_m18(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(18usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m18_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 18usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m18_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 18usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m19(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u8) } + } + #[inline] + pub fn set_m19(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m19_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 19usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m19_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m20(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u8) } + } + #[inline] + pub fn set_m20(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m20_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 20usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m20_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 20usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m21(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u8) } + } + #[inline] + pub fn set_m21(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m21_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 21usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m21_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 21usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m22(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u8) } + } + #[inline] + pub fn set_m22(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m22_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 22usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m22_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 22usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m23(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u8) } + } + #[inline] + pub fn set_m23(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m23_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 23usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m23_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m24(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u8) } + } + #[inline] + pub fn set_m24(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m24_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 24usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m24_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m25(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u8) } + } + #[inline] + pub fn set_m25(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(25usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m25_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 25usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m25_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 25usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m26(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u8) } + } + #[inline] + pub fn set_m26(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(26usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m26_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 26usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m26_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 26usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m27(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u8) } + } + #[inline] + pub fn set_m27(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(27usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m27_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 27usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m27_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 27usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m28(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u8) } + } + #[inline] + pub fn set_m28(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(28usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m28_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 28usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m28_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 28usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m29(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u8) } + } + #[inline] + pub fn set_m29(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(29usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m29_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 29usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m29_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 29usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m30(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u8) } + } + #[inline] + pub fn set_m30(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(30usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m30_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 30usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m30_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 30usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m31(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u8) } + } + #[inline] + pub fn set_m31(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(31usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m31_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 31usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m31_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 31usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn m32(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u8) } + } + #[inline] + pub fn set_m32(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(32usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn m32_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 32usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_m32_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 5usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 32usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + m0: ::std::os::raw::c_char, + m1: ::std::os::raw::c_char, + m2: ::std::os::raw::c_char, + m3: ::std::os::raw::c_char, + m4: ::std::os::raw::c_char, + m5: ::std::os::raw::c_char, + m6: ::std::os::raw::c_char, + m7: ::std::os::raw::c_char, + m8: ::std::os::raw::c_char, + m9: ::std::os::raw::c_char, + m10: ::std::os::raw::c_char, + m11: ::std::os::raw::c_char, + m12: ::std::os::raw::c_char, + m13: ::std::os::raw::c_char, + m14: ::std::os::raw::c_char, + m15: ::std::os::raw::c_char, + m16: ::std::os::raw::c_char, + m17: ::std::os::raw::c_char, + m18: ::std::os::raw::c_char, + m19: ::std::os::raw::c_char, + m20: ::std::os::raw::c_char, + m21: ::std::os::raw::c_char, + m22: ::std::os::raw::c_char, + m23: ::std::os::raw::c_char, + m24: ::std::os::raw::c_char, + m25: ::std::os::raw::c_char, + m26: ::std::os::raw::c_char, + m27: ::std::os::raw::c_char, + m28: ::std::os::raw::c_char, + m29: ::std::os::raw::c_char, + m30: ::std::os::raw::c_char, + m31: ::std::os::raw::c_char, + m32: ::std::os::raw::c_char, + ) -> __BindgenBitfieldUnit<[u8; 5usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 5usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let m0: u8 = unsafe { ::std::mem::transmute(m0) }; + m0 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 1u8, + { + let m1: u8 = unsafe { ::std::mem::transmute(m1) }; + m1 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 2usize, + 1u8, + { + let m2: u8 = unsafe { ::std::mem::transmute(m2) }; + m2 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 3usize, + 1u8, + { + let m3: u8 = unsafe { ::std::mem::transmute(m3) }; + m3 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 4usize, + 1u8, + { + let m4: u8 = unsafe { ::std::mem::transmute(m4) }; + m4 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 5usize, + 1u8, + { + let m5: u8 = unsafe { ::std::mem::transmute(m5) }; + m5 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 6usize, + 1u8, + { + let m6: u8 = unsafe { ::std::mem::transmute(m6) }; + m6 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 7usize, + 1u8, + { + let m7: u8 = unsafe { ::std::mem::transmute(m7) }; + m7 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 8usize, + 1u8, + { + let m8: u8 = unsafe { ::std::mem::transmute(m8) }; + m8 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 9usize, + 1u8, + { + let m9: u8 = unsafe { ::std::mem::transmute(m9) }; + m9 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 10usize, + 1u8, + { + let m10: u8 = unsafe { ::std::mem::transmute(m10) }; + m10 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 11usize, + 1u8, + { + let m11: u8 = unsafe { ::std::mem::transmute(m11) }; + m11 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 12usize, + 1u8, + { + let m12: u8 = unsafe { ::std::mem::transmute(m12) }; + m12 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 13usize, + 1u8, + { + let m13: u8 = unsafe { ::std::mem::transmute(m13) }; + m13 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 14usize, + 1u8, + { + let m14: u8 = unsafe { ::std::mem::transmute(m14) }; + m14 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 15usize, + 1u8, + { + let m15: u8 = unsafe { ::std::mem::transmute(m15) }; + m15 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 16usize, + 1u8, + { + let m16: u8 = unsafe { ::std::mem::transmute(m16) }; + m16 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 17usize, + 1u8, + { + let m17: u8 = unsafe { ::std::mem::transmute(m17) }; + m17 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 18usize, + 1u8, + { + let m18: u8 = unsafe { ::std::mem::transmute(m18) }; + m18 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 19usize, + 1u8, + { + let m19: u8 = unsafe { ::std::mem::transmute(m19) }; + m19 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 20usize, + 1u8, + { + let m20: u8 = unsafe { ::std::mem::transmute(m20) }; + m20 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 21usize, + 1u8, + { + let m21: u8 = unsafe { ::std::mem::transmute(m21) }; + m21 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 22usize, + 1u8, + { + let m22: u8 = unsafe { ::std::mem::transmute(m22) }; + m22 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 23usize, + 1u8, + { + let m23: u8 = unsafe { ::std::mem::transmute(m23) }; + m23 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 24usize, + 1u8, + { + let m24: u8 = unsafe { ::std::mem::transmute(m24) }; + m24 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 25usize, + 1u8, + { + let m25: u8 = unsafe { ::std::mem::transmute(m25) }; + m25 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 26usize, + 1u8, + { + let m26: u8 = unsafe { ::std::mem::transmute(m26) }; + m26 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 27usize, + 1u8, + { + let m27: u8 = unsafe { ::std::mem::transmute(m27) }; + m27 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 28usize, + 1u8, + { + let m28: u8 = unsafe { ::std::mem::transmute(m28) }; + m28 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 29usize, + 1u8, + { + let m29: u8 = unsafe { ::std::mem::transmute(m29) }; + m29 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 30usize, + 1u8, + { + let m30: u8 = unsafe { ::std::mem::transmute(m30) }; + m30 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 31usize, + 1u8, + { + let m31: u8 = unsafe { ::std::mem::transmute(m31) }; + m31 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 32usize, + 1u8, + { + let m32: u8 = unsafe { ::std::mem::transmute(m32) }; + m32 as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/bitfield-enum-basic.rs b/bindgen-tests/tests/expectations/tests/bitfield-enum-basic.rs new file mode 100644 index 0000000000..aecb9dc639 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/bitfield-enum-basic.rs @@ -0,0 +1,143 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +impl Foo { + pub const Bar: Foo = Foo(2); + pub const Baz: Foo = Foo(4); + pub const Duplicated: Foo = Foo(4); + pub const Negative: Foo = Foo(-3); +} +impl ::std::ops::BitOr for Foo { + type Output = Self; + #[inline] + fn bitor(self, other: Self) -> Self { + Foo(self.0 | other.0) + } +} +impl ::std::ops::BitOrAssign for Foo { + #[inline] + fn bitor_assign(&mut self, rhs: Foo) { + self.0 |= rhs.0; + } +} +impl ::std::ops::BitAnd for Foo { + type Output = Self; + #[inline] + fn bitand(self, other: Self) -> Self { + Foo(self.0 & other.0) + } +} +impl ::std::ops::BitAndAssign for Foo { + #[inline] + fn bitand_assign(&mut self, rhs: Foo) { + self.0 &= rhs.0; + } +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Foo(pub ::std::os::raw::c_int); +impl Buz { + pub const Bar: Buz = Buz(2); + pub const Baz: Buz = Buz(4); + pub const Duplicated: Buz = Buz(4); + pub const Negative: Buz = Buz(-3); +} +impl ::std::ops::BitOr for Buz { + type Output = Self; + #[inline] + fn bitor(self, other: Self) -> Self { + Buz(self.0 | other.0) + } +} +impl ::std::ops::BitOrAssign for Buz { + #[inline] + fn bitor_assign(&mut self, rhs: Buz) { + self.0 |= rhs.0; + } +} +impl ::std::ops::BitAnd for Buz { + type Output = Self; + #[inline] + fn bitand(self, other: Self) -> Self { + Buz(self.0 & other.0) + } +} +impl ::std::ops::BitAndAssign for Buz { + #[inline] + fn bitand_assign(&mut self, rhs: Buz) { + self.0 &= rhs.0; + } +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Buz(pub ::std::os::raw::c_schar); +pub const NS_FOO: _bindgen_ty_1 = _bindgen_ty_1(1); +pub const NS_BAR: _bindgen_ty_1 = _bindgen_ty_1(2); +impl ::std::ops::BitOr<_bindgen_ty_1> for _bindgen_ty_1 { + type Output = Self; + #[inline] + fn bitor(self, other: Self) -> Self { + _bindgen_ty_1(self.0 | other.0) + } +} +impl ::std::ops::BitOrAssign for _bindgen_ty_1 { + #[inline] + fn bitor_assign(&mut self, rhs: _bindgen_ty_1) { + self.0 |= rhs.0; + } +} +impl ::std::ops::BitAnd<_bindgen_ty_1> for _bindgen_ty_1 { + type Output = Self; + #[inline] + fn bitand(self, other: Self) -> Self { + _bindgen_ty_1(self.0 & other.0) + } +} +impl ::std::ops::BitAndAssign for _bindgen_ty_1 { + #[inline] + fn bitand_assign(&mut self, rhs: _bindgen_ty_1) { + self.0 &= rhs.0; + } +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct _bindgen_ty_1(pub ::std::os::raw::c_uint); +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Dummy { + pub _address: u8, +} +pub const Dummy_DUMMY_FOO: Dummy__bindgen_ty_1 = Dummy__bindgen_ty_1(1); +pub const Dummy_DUMMY_BAR: Dummy__bindgen_ty_1 = Dummy__bindgen_ty_1(2); +impl ::std::ops::BitOr for Dummy__bindgen_ty_1 { + type Output = Self; + #[inline] + fn bitor(self, other: Self) -> Self { + Dummy__bindgen_ty_1(self.0 | other.0) + } +} +impl ::std::ops::BitOrAssign for Dummy__bindgen_ty_1 { + #[inline] + fn bitor_assign(&mut self, rhs: Dummy__bindgen_ty_1) { + self.0 |= rhs.0; + } +} +impl ::std::ops::BitAnd for Dummy__bindgen_ty_1 { + type Output = Self; + #[inline] + fn bitand(self, other: Self) -> Self { + Dummy__bindgen_ty_1(self.0 & other.0) + } +} +impl ::std::ops::BitAndAssign for Dummy__bindgen_ty_1 { + #[inline] + fn bitand_assign(&mut self, rhs: Dummy__bindgen_ty_1) { + self.0 &= rhs.0; + } +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Dummy__bindgen_ty_1(pub ::std::os::raw::c_uint); +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Dummy"][::std::mem::size_of::() - 1usize]; + ["Alignment of Dummy"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/bitfield-enum-repr-c.rs b/bindgen-tests/tests/expectations/tests/bitfield-enum-repr-c.rs new file mode 100644 index 0000000000..df5a69eddd --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/bitfield-enum-repr-c.rs @@ -0,0 +1,36 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +impl Foo { + pub const Bar: Foo = Foo(2); + pub const Baz: Foo = Foo(4); + pub const Duplicated: Foo = Foo(4); + pub const Negative: Foo = Foo(-3); +} +impl ::std::ops::BitOr for Foo { + type Output = Self; + #[inline] + fn bitor(self, other: Self) -> Self { + Foo(self.0 | other.0) + } +} +impl ::std::ops::BitOrAssign for Foo { + #[inline] + fn bitor_assign(&mut self, rhs: Foo) { + self.0 |= rhs.0; + } +} +impl ::std::ops::BitAnd for Foo { + type Output = Self; + #[inline] + fn bitand(self, other: Self) -> Self { + Foo(self.0 & other.0) + } +} +impl ::std::ops::BitAndAssign for Foo { + #[inline] + fn bitand_assign(&mut self, rhs: Foo) { + self.0 &= rhs.0; + } +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Foo(pub ::std::os::raw::c_int); diff --git a/bindgen-tests/tests/expectations/tests/bitfield-enum-repr-transparent.rs b/bindgen-tests/tests/expectations/tests/bitfield-enum-repr-transparent.rs new file mode 100644 index 0000000000..df5a69eddd --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/bitfield-enum-repr-transparent.rs @@ -0,0 +1,36 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +impl Foo { + pub const Bar: Foo = Foo(2); + pub const Baz: Foo = Foo(4); + pub const Duplicated: Foo = Foo(4); + pub const Negative: Foo = Foo(-3); +} +impl ::std::ops::BitOr for Foo { + type Output = Self; + #[inline] + fn bitor(self, other: Self) -> Self { + Foo(self.0 | other.0) + } +} +impl ::std::ops::BitOrAssign for Foo { + #[inline] + fn bitor_assign(&mut self, rhs: Foo) { + self.0 |= rhs.0; + } +} +impl ::std::ops::BitAnd for Foo { + type Output = Self; + #[inline] + fn bitand(self, other: Self) -> Self { + Foo(self.0 & other.0) + } +} +impl ::std::ops::BitAndAssign for Foo { + #[inline] + fn bitand_assign(&mut self, rhs: Foo) { + self.0 &= rhs.0; + } +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Foo(pub ::std::os::raw::c_int); diff --git a/bindgen-tests/tests/expectations/tests/bitfield-large.rs b/bindgen-tests/tests/expectations/tests/bitfield-large.rs new file mode 100644 index 0000000000..5d614ab936 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/bitfield-large.rs @@ -0,0 +1,322 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct HasBigBitfield { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of HasBigBitfield"][::std::mem::size_of::() - 16usize]; + ["Alignment of HasBigBitfield"][::std::mem::align_of::() - 16usize]; +}; +impl HasBigBitfield { + #[inline] + pub fn x(&self) -> i128 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 128u8) as u128) } + } + #[inline] + pub fn set_x(&mut self, val: i128) { + unsafe { + let val: u128 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 128u8, val as u64) + } + } + #[inline] + pub unsafe fn x_raw(this: *const Self) -> i128 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 128u8) + as u128, + ) + } + } + #[inline] + pub unsafe fn set_x_raw(this: *mut Self, val: i128) { + unsafe { + let val: u128 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 128u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(x: i128) -> __BindgenBitfieldUnit<[u8; 16usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 128u8, + { + let x: u128 = unsafe { ::std::mem::transmute(x) }; + x as u64 + }, + ); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct HasTwoBigBitfields { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of HasTwoBigBitfields", + ][::std::mem::size_of::() - 16usize]; + [ + "Alignment of HasTwoBigBitfields", + ][::std::mem::align_of::() - 16usize]; +}; +impl HasTwoBigBitfields { + #[inline] + pub fn x(&self) -> i128 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 80u8) as u128) } + } + #[inline] + pub fn set_x(&mut self, val: i128) { + unsafe { + let val: u128 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 80u8, val as u64) + } + } + #[inline] + pub unsafe fn x_raw(this: *const Self) -> i128 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 80u8) + as u128, + ) + } + } + #[inline] + pub unsafe fn set_x_raw(this: *mut Self, val: i128) { + unsafe { + let val: u128 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 80u8, + val as u64, + ) + } + } + #[inline] + pub fn y(&self) -> i128 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 48u8) as u128) } + } + #[inline] + pub fn set_y(&mut self, val: i128) { + unsafe { + let val: u128 = ::std::mem::transmute(val); + self._bitfield_1.set(80usize, 48u8, val as u64) + } + } + #[inline] + pub unsafe fn y_raw(this: *const Self) -> i128 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 80usize, 48u8) + as u128, + ) + } + } + #[inline] + pub unsafe fn set_y_raw(this: *mut Self, val: i128) { + unsafe { + let val: u128 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 80usize, + 48u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(x: i128, y: i128) -> __BindgenBitfieldUnit<[u8; 16usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 80u8, + { + let x: u128 = unsafe { ::std::mem::transmute(x) }; + x as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 80usize, + 48u8, + { + let y: u128 = unsafe { ::std::mem::transmute(y) }; + y as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/bitfield-linux-32.rs b/bindgen-tests/tests/expectations/tests/bitfield-linux-32.rs new file mode 100644 index 0000000000..3e676c53b5 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/bitfield-linux-32.rs @@ -0,0 +1,250 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Test { + pub foo: u64, + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, +} +impl Test { + #[inline] + pub fn x(&self) -> u64 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 56u8) as u64) } + } + #[inline] + pub fn set_x(&mut self, val: u64) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 56u8, val as u64) + } + } + #[inline] + pub unsafe fn x_raw(this: *const Self) -> u64 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 8usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 56u8) + as u64, + ) + } + } + #[inline] + pub unsafe fn set_x_raw(this: *mut Self, val: u64) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 8usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 56u8, + val as u64, + ) + } + } + #[inline] + pub fn y(&self) -> u64 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(56usize, 8u8) as u64) } + } + #[inline] + pub fn set_y(&mut self, val: u64) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + self._bitfield_1.set(56usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn y_raw(this: *const Self) -> u64 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 8usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 56usize, 8u8) + as u64, + ) + } + } + #[inline] + pub unsafe fn set_y_raw(this: *mut Self, val: u64) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 8usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 56usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(x: u64, y: u64) -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 56u8, + { + let x: u64 = unsafe { ::std::mem::transmute(x) }; + x as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 56usize, + 8u8, + { + let y: u64 = unsafe { ::std::mem::transmute(y) }; + y as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/bitfield-method-same-name.rs b/bindgen-tests/tests/expectations/tests/bitfield-method-same-name.rs new file mode 100644 index 0000000000..09ca005589 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/bitfield-method-same-name.rs @@ -0,0 +1,241 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN3Foo4typeEv"] + pub fn Foo_type(this: *mut Foo) -> ::std::os::raw::c_char; +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN3Foo9set_type_Ec"] + pub fn Foo_set_type_(this: *mut Foo, c: ::std::os::raw::c_char); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN3Foo8set_typeEc"] + pub fn Foo_set_type(this: *mut Foo, c: ::std::os::raw::c_char); +} +impl Foo { + #[inline] + pub fn type__bindgen_bitfield(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u8) } + } + #[inline] + pub fn set_type__bindgen_bitfield(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn type__bindgen_bitfield_raw( + this: *const Self, + ) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 3u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_type__bindgen_bitfield_raw( + this: *mut Self, + val: ::std::os::raw::c_char, + ) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + type__bindgen_bitfield: ::std::os::raw::c_char, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 3u8, + { + let type__bindgen_bitfield: u8 = unsafe { + ::std::mem::transmute(type__bindgen_bitfield) + }; + type__bindgen_bitfield as u64 + }, + ); + __bindgen_bitfield_unit + } + #[inline] + pub unsafe fn type_(&mut self) -> ::std::os::raw::c_char { + Foo_type(self) + } + #[inline] + pub unsafe fn set_type_(&mut self, c: ::std::os::raw::c_char) { + Foo_set_type_(self, c) + } + #[inline] + pub unsafe fn set_type(&mut self, c: ::std::os::raw::c_char) { + Foo_set_type(self, c) + } +} diff --git a/bindgen-tests/tests/expectations/tests/bitfield-template.rs b/bindgen-tests/tests/expectations/tests/bitfield-template.rs new file mode 100644 index 0000000000..eb454e0db4 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/bitfield-template.rs @@ -0,0 +1,214 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct foo { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub member: T, + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, +} +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl foo { + #[inline] + pub fn b(&self) -> bool { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u8) } + } + #[inline] + pub fn set_b(&mut self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn b_raw(this: *const Self) -> bool { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 8u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_b_raw(this: *mut Self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(b: bool) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 8u8, + { + let b: u8 = unsafe { ::std::mem::transmute(b) }; + b as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/bitfield_align.rs b/bindgen-tests/tests/expectations/tests/bitfield_align.rs new file mode 100644 index 0000000000..0c70917fc5 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/bitfield_align.rs @@ -0,0 +1,1513 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct A { + pub _bindgen_align: [u32; 0], + pub x: ::std::os::raw::c_uchar, + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, + pub y: ::std::os::raw::c_uchar, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A"][::std::mem::size_of::() - 4usize]; + ["Alignment of A"][::std::mem::align_of::() - 4usize]; + ["Offset of field: A::x"][::std::mem::offset_of!(A, x) - 0usize]; + ["Offset of field: A::y"][::std::mem::offset_of!(A, y) - 3usize]; +}; +impl A { + #[inline] + pub fn b1(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_b1(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn b1_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_b1_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn b2(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_b2(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn b2_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_b2_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn b3(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_b3(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn b3_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_b3_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn b4(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_b4(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn b4_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 3usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_b4_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn b5(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_b5(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn b5_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_b5_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn b6(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_b6(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn b6_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 5usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_b6_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn b7(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_b7(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn b7_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 6usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_b7_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn b8(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_b8(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn b8_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 7usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_b8_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn b9(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_b9(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn b9_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 8usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_b9_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn b10(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_b10(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn b10_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 9usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_b10_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 9usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + b1: ::std::os::raw::c_uint, + b2: ::std::os::raw::c_uint, + b3: ::std::os::raw::c_uint, + b4: ::std::os::raw::c_uint, + b5: ::std::os::raw::c_uint, + b6: ::std::os::raw::c_uint, + b7: ::std::os::raw::c_uint, + b8: ::std::os::raw::c_uint, + b9: ::std::os::raw::c_uint, + b10: ::std::os::raw::c_uint, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let b1: u32 = unsafe { ::std::mem::transmute(b1) }; + b1 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 1u8, + { + let b2: u32 = unsafe { ::std::mem::transmute(b2) }; + b2 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 2usize, + 1u8, + { + let b3: u32 = unsafe { ::std::mem::transmute(b3) }; + b3 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 3usize, + 1u8, + { + let b4: u32 = unsafe { ::std::mem::transmute(b4) }; + b4 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 4usize, + 1u8, + { + let b5: u32 = unsafe { ::std::mem::transmute(b5) }; + b5 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 5usize, + 1u8, + { + let b6: u32 = unsafe { ::std::mem::transmute(b6) }; + b6 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 6usize, + 1u8, + { + let b7: u32 = unsafe { ::std::mem::transmute(b7) }; + b7 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 7usize, + 1u8, + { + let b8: u32 = unsafe { ::std::mem::transmute(b8) }; + b8 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 8usize, + 1u8, + { + let b9: u32 = unsafe { ::std::mem::transmute(b9) }; + b9 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 9usize, + 1u8, + { + let b10: u32 = unsafe { ::std::mem::transmute(b10) }; + b10 as u64 + }, + ); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct B { + pub _bindgen_align: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of B"][::std::mem::size_of::() - 4usize]; + ["Alignment of B"][::std::mem::align_of::() - 4usize]; +}; +impl B { + #[inline] + pub fn foo(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 31u8) as u32) } + } + #[inline] + pub fn set_foo(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn foo_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 31u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_foo_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn bar(&self) -> ::std::os::raw::c_uchar { + unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u8) } + } + #[inline] + pub fn set_bar(&mut self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(31usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bar_raw(this: *const Self) -> ::std::os::raw::c_uchar { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 31usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_bar_raw(this: *mut Self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 31usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + foo: ::std::os::raw::c_uint, + bar: ::std::os::raw::c_uchar, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 31u8, + { + let foo: u32 = unsafe { ::std::mem::transmute(foo) }; + foo as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 31usize, + 1u8, + { + let bar: u8 = unsafe { ::std::mem::transmute(bar) }; + bar as u64 + }, + ); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct C { + pub x: ::std::os::raw::c_uchar, + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub baz: ::std::os::raw::c_uint, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C"][::std::mem::size_of::() - 8usize]; + ["Alignment of C"][::std::mem::align_of::() - 4usize]; + ["Offset of field: C::x"][::std::mem::offset_of!(C, x) - 0usize]; + ["Offset of field: C::baz"][::std::mem::offset_of!(C, baz) - 4usize]; +}; +impl C { + #[inline] + pub fn b1(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_b1(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn b1_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_b1_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn b2(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_b2(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn b2_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_b2_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + b1: ::std::os::raw::c_uint, + b2: ::std::os::raw::c_uint, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let b1: u32 = unsafe { ::std::mem::transmute(b1) }; + b1 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 1u8, + { + let b2: u32 = unsafe { ::std::mem::transmute(b2) }; + b2 as u64 + }, + ); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Date1 { + pub _bindgen_align: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, + pub __bindgen_padding_0: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Date1"][::std::mem::size_of::() - 4usize]; + ["Alignment of Date1"][::std::mem::align_of::() - 2usize]; +}; +impl Date1 { + #[inline] + pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u16) } + } + #[inline] + pub fn set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn nWeekDay_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 3u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_nWeekDay_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 6u8) as u16) } + } + #[inline] + pub fn set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 6u8, val as u64) + } + } + #[inline] + pub unsafe fn nMonthDay_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 3usize, 6u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_nMonthDay_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 6u8, + val as u64, + ) + } + } + #[inline] + pub fn nMonth(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 5u8) as u16) } + } + #[inline] + pub fn set_nMonth(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn nMonth_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 9usize, 5u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_nMonth_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 9usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn nYear(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u16) } + } + #[inline] + pub fn set_nYear(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn nYear_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 16usize, 8u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_nYear_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + nWeekDay: ::std::os::raw::c_ushort, + nMonthDay: ::std::os::raw::c_ushort, + nMonth: ::std::os::raw::c_ushort, + nYear: ::std::os::raw::c_ushort, + ) -> __BindgenBitfieldUnit<[u8; 3usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 3u8, + { + let nWeekDay: u16 = unsafe { ::std::mem::transmute(nWeekDay) }; + nWeekDay as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 3usize, + 6u8, + { + let nMonthDay: u16 = unsafe { ::std::mem::transmute(nMonthDay) }; + nMonthDay as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 9usize, + 5u8, + { + let nMonth: u16 = unsafe { ::std::mem::transmute(nMonth) }; + nMonth as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 16usize, + 8u8, + { + let nYear: u16 = unsafe { ::std::mem::transmute(nYear) }; + nYear as u64 + }, + ); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Date2 { + pub _bindgen_align: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Date2"][::std::mem::size_of::() - 4usize]; + ["Alignment of Date2"][::std::mem::align_of::() - 2usize]; +}; +impl Date2 { + #[inline] + pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u16) } + } + #[inline] + pub fn set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn nWeekDay_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 3u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_nWeekDay_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 6u8) as u16) } + } + #[inline] + pub fn set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 6u8, val as u64) + } + } + #[inline] + pub unsafe fn nMonthDay_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 3usize, 6u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_nMonthDay_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 6u8, + val as u64, + ) + } + } + #[inline] + pub fn nMonth(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 5u8) as u16) } + } + #[inline] + pub fn set_nMonth(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn nMonth_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 9usize, 5u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_nMonth_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 9usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn nYear(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u16) } + } + #[inline] + pub fn set_nYear(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn nYear_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 16usize, 8u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_nYear_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn byte(&self) -> ::std::os::raw::c_uchar { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u8) } + } + #[inline] + pub fn set_byte(&mut self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn byte_raw(this: *const Self) -> ::std::os::raw::c_uchar { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 24usize, 8u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_byte_raw(this: *mut Self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + nWeekDay: ::std::os::raw::c_ushort, + nMonthDay: ::std::os::raw::c_ushort, + nMonth: ::std::os::raw::c_ushort, + nYear: ::std::os::raw::c_ushort, + byte: ::std::os::raw::c_uchar, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 3u8, + { + let nWeekDay: u16 = unsafe { ::std::mem::transmute(nWeekDay) }; + nWeekDay as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 3usize, + 6u8, + { + let nMonthDay: u16 = unsafe { ::std::mem::transmute(nMonthDay) }; + nMonthDay as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 9usize, + 5u8, + { + let nMonth: u16 = unsafe { ::std::mem::transmute(nMonth) }; + nMonth as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 16usize, + 8u8, + { + let nYear: u16 = unsafe { ::std::mem::transmute(nYear) }; + nYear as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 24usize, + 8u8, + { + let byte: u8 = unsafe { ::std::mem::transmute(byte) }; + byte as u64 + }, + ); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Date3 { + pub _bindgen_align: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, + pub byte: ::std::os::raw::c_uchar, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Date3"][::std::mem::size_of::() - 4usize]; + ["Alignment of Date3"][::std::mem::align_of::() - 2usize]; + ["Offset of field: Date3::byte"][::std::mem::offset_of!(Date3, byte) - 3usize]; +}; +impl Date3 { + #[inline] + pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u16) } + } + #[inline] + pub fn set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn nWeekDay_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 3u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_nWeekDay_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 6u8) as u16) } + } + #[inline] + pub fn set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 6u8, val as u64) + } + } + #[inline] + pub unsafe fn nMonthDay_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 3usize, 6u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_nMonthDay_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 6u8, + val as u64, + ) + } + } + #[inline] + pub fn nMonth(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 5u8) as u16) } + } + #[inline] + pub fn set_nMonth(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn nMonth_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 9usize, 5u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_nMonth_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 9usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn nYear(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u16) } + } + #[inline] + pub fn set_nYear(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn nYear_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 16usize, 8u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_nYear_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + nWeekDay: ::std::os::raw::c_ushort, + nMonthDay: ::std::os::raw::c_ushort, + nMonth: ::std::os::raw::c_ushort, + nYear: ::std::os::raw::c_ushort, + ) -> __BindgenBitfieldUnit<[u8; 3usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 3u8, + { + let nWeekDay: u16 = unsafe { ::std::mem::transmute(nWeekDay) }; + nWeekDay as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 3usize, + 6u8, + { + let nMonthDay: u16 = unsafe { ::std::mem::transmute(nMonthDay) }; + nMonthDay as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 9usize, + 5u8, + { + let nMonth: u16 = unsafe { ::std::mem::transmute(nMonth) }; + nMonth as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 16usize, + 8u8, + { + let nYear: u16 = unsafe { ::std::mem::transmute(nYear) }; + nYear as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/bitfield_align_2.rs b/bindgen-tests/tests/expectations/tests/bitfield_align_2.rs new file mode 100644 index 0000000000..b71bba18ad --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/bitfield_align_2.rs @@ -0,0 +1,276 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(not(target_os = "windows"))] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum MyEnum { + ONE = 0, + TWO = 1, + THREE = 2, + FOUR = 3, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct TaggedPtr { + pub _bindgen_align: [u64; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of TaggedPtr"][::std::mem::size_of::() - 8usize]; + ["Alignment of TaggedPtr"][::std::mem::align_of::() - 8usize]; +}; +impl Default for TaggedPtr { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl TaggedPtr { + #[inline] + pub fn tag(&self) -> MyEnum { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) } + } + #[inline] + pub fn set_tag(&mut self, val: MyEnum) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn tag_raw(this: *const Self) -> MyEnum { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 8usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 2u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_tag_raw(this: *mut Self, val: MyEnum) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 8usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn ptr(&self) -> ::std::os::raw::c_long { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 62u8) as u64) } + } + #[inline] + pub fn set_ptr(&mut self, val: ::std::os::raw::c_long) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 62u8, val as u64) + } + } + #[inline] + pub unsafe fn ptr_raw(this: *const Self) -> ::std::os::raw::c_long { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 8usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 62u8) + as u64, + ) + } + } + #[inline] + pub unsafe fn set_ptr_raw(this: *mut Self, val: ::std::os::raw::c_long) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 8usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 62u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + tag: MyEnum, + ptr: ::std::os::raw::c_long, + ) -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 2u8, + { + let tag: u32 = unsafe { ::std::mem::transmute(tag) }; + tag as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 2usize, + 62u8, + { + let ptr: u64 = unsafe { ::std::mem::transmute(ptr) }; + ptr as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/bitfield_large_overflow.rs b/bindgen-tests/tests/expectations/tests/bitfield_large_overflow.rs new file mode 100644 index 0000000000..ac5d75735e --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/bitfield_large_overflow.rs @@ -0,0 +1,23 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)] +#[repr(C, align(8))] +pub struct __BindgenOpaqueArray8(pub T); +impl Default for __BindgenOpaqueArray8<[T; N]> { + fn default() -> Self { + Self([::default(); N]) + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _bindgen_ty_1 { + pub _bindgen_align: [u64; 0], + pub _bindgen_opaque_blob: __BindgenOpaqueArray8<[u8; 80usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _bindgen_ty_1"][::std::mem::size_of::<_bindgen_ty_1>() - 80usize]; + ["Alignment of _bindgen_ty_1"][::std::mem::align_of::<_bindgen_ty_1>() - 8usize]; +}; +unsafe extern "C" { + pub static mut a: _bindgen_ty_1; +} diff --git a/bindgen-tests/tests/expectations/tests/bitfield_method_mangling.rs b/bindgen-tests/tests/expectations/tests/bitfield_method_mangling.rs new file mode 100644 index 0000000000..35117c74b6 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/bitfield_method_mangling.rs @@ -0,0 +1,262 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct mach_msg_type_descriptor_t { + pub _bindgen_align: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of mach_msg_type_descriptor_t", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of mach_msg_type_descriptor_t", + ][::std::mem::align_of::() - 4usize]; +}; +impl mach_msg_type_descriptor_t { + #[inline] + pub fn pad3(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 24u8) as u32) } + } + #[inline] + pub fn set_pad3(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 24u8, val as u64) + } + } + #[inline] + pub unsafe fn pad3_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 24u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_pad3_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 24u8, + val as u64, + ) + } + } + #[inline] + pub fn type_(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } + } + #[inline] + pub fn set_type(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn type__raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 24usize, 8u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_type_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + pad3: ::std::os::raw::c_uint, + type_: ::std::os::raw::c_uint, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 24u8, + { + let pad3: u32 = unsafe { ::std::mem::transmute(pad3) }; + pad3 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 24usize, + 8u8, + { + let type_: u32 = unsafe { ::std::mem::transmute(type_) }; + type_ as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/bitfield_pack_offset.rs b/bindgen-tests/tests/expectations/tests/bitfield_pack_offset.rs new file mode 100644 index 0000000000..d654e25b27 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/bitfield_pack_offset.rs @@ -0,0 +1,507 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct A { + pub name: [::std::os::raw::c_uchar; 7usize], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, + pub maxYield: ::std::os::raw::c_uchar, + pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, + pub description1: *const ::std::os::raw::c_uchar, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A"][::std::mem::size_of::() - 24usize]; + ["Alignment of A"][::std::mem::align_of::() - 8usize]; + ["Offset of field: A::name"][::std::mem::offset_of!(A, name) - 0usize]; + ["Offset of field: A::maxYield"][::std::mem::offset_of!(A, maxYield) - 10usize]; + [ + "Offset of field: A::description1", + ][::std::mem::offset_of!(A, description1) - 16usize]; +}; +impl Default for A { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl A { + #[inline] + pub fn firmness(&self) -> ::std::os::raw::c_uchar { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) } + } + #[inline] + pub fn set_firmness(&mut self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn firmness_raw(this: *const Self) -> ::std::os::raw::c_uchar { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 4u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_firmness_raw(this: *mut Self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn color(&self) -> ::std::os::raw::c_uchar { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) } + } + #[inline] + pub fn set_color(&mut self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn color_raw(this: *const Self) -> ::std::os::raw::c_uchar { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 4u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_color_raw(this: *mut Self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn weedsBonus(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u16) } + } + #[inline] + pub fn set_weedsBonus(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn weedsBonus_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 8usize, 3u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_weedsBonus_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn pestsBonus(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 3u8) as u16) } + } + #[inline] + pub fn set_pestsBonus(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn pestsBonus_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 11usize, 3u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_pestsBonus_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn size(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 10u8) as u16) } + } + #[inline] + pub fn set_size(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 10u8, val as u64) + } + } + #[inline] + pub unsafe fn size_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 14usize, 10u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_size_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 10u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + firmness: ::std::os::raw::c_uchar, + color: ::std::os::raw::c_uchar, + weedsBonus: ::std::os::raw::c_ushort, + pestsBonus: ::std::os::raw::c_ushort, + size: ::std::os::raw::c_ushort, + ) -> __BindgenBitfieldUnit<[u8; 3usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 4u8, + { + let firmness: u8 = unsafe { ::std::mem::transmute(firmness) }; + firmness as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 4usize, + 4u8, + { + let color: u8 = unsafe { ::std::mem::transmute(color) }; + color as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 8usize, + 3u8, + { + let weedsBonus: u16 = unsafe { ::std::mem::transmute(weedsBonus) }; + weedsBonus as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 11usize, + 3u8, + { + let pestsBonus: u16 = unsafe { ::std::mem::transmute(pestsBonus) }; + pestsBonus as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 14usize, + 10u8, + { + let size: u16 = unsafe { ::std::mem::transmute(size) }; + size as u64 + }, + ); + __bindgen_bitfield_unit + } + #[inline] + pub fn minYield(&self) -> ::std::os::raw::c_uchar { + unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 4u8) as u8) } + } + #[inline] + pub fn set_minYield(&mut self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn minYield_raw(this: *const Self) -> ::std::os::raw::c_uchar { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_2), 0usize, 4u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_minYield_raw(this: *mut Self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn waterBonus(&self) -> ::std::os::raw::c_uchar { + unsafe { ::std::mem::transmute(self._bitfield_2.get(4usize, 4u8) as u8) } + } + #[inline] + pub fn set_waterBonus(&mut self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(4usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn waterBonus_raw(this: *const Self) -> ::std::os::raw::c_uchar { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_2), 4usize, 4u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_waterBonus_raw(this: *mut Self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 4usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_2( + minYield: ::std::os::raw::c_uchar, + waterBonus: ::std::os::raw::c_uchar, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 4u8, + { + let minYield: u8 = unsafe { ::std::mem::transmute(minYield) }; + minYield as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 4usize, + 4u8, + { + let waterBonus: u8 = unsafe { ::std::mem::transmute(waterBonus) }; + waterBonus as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/bitfield_pragma_packed.rs b/bindgen-tests/tests/expectations/tests/bitfield_pragma_packed.rs new file mode 100644 index 0000000000..6f9adcb5ab --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/bitfield_pragma_packed.rs @@ -0,0 +1,514 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Struct { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Struct"][::std::mem::size_of::() - 4usize]; + ["Alignment of Struct"][::std::mem::align_of::() - 1usize]; +}; +impl Struct { + #[inline] + pub fn a(&self) -> ::std::os::raw::c_uchar { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_a(&mut self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn a_raw(this: *const Self) -> ::std::os::raw::c_uchar { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_a_raw(this: *mut Self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn b(&self) -> ::std::os::raw::c_uchar { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } + } + #[inline] + pub fn set_b(&mut self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn b_raw(this: *const Self) -> ::std::os::raw::c_uchar { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_b_raw(this: *mut Self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn c(&self) -> ::std::os::raw::c_uchar { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 6u8) as u8) } + } + #[inline] + pub fn set_c(&mut self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 6u8, val as u64) + } + } + #[inline] + pub unsafe fn c_raw(this: *const Self) -> ::std::os::raw::c_uchar { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 6u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_c_raw(this: *mut Self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 6u8, + val as u64, + ) + } + } + #[inline] + pub fn d(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 16u8) as u16) } + } + #[inline] + pub fn set_d(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 16u8, val as u64) + } + } + #[inline] + pub unsafe fn d_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 8usize, 16u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_d_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 16u8, + val as u64, + ) + } + } + #[inline] + pub fn e(&self) -> ::std::os::raw::c_uchar { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u8) } + } + #[inline] + pub fn set_e(&mut self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn e_raw(this: *const Self) -> ::std::os::raw::c_uchar { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 24usize, 8u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_e_raw(this: *mut Self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + a: ::std::os::raw::c_uchar, + b: ::std::os::raw::c_uchar, + c: ::std::os::raw::c_uchar, + d: ::std::os::raw::c_ushort, + e: ::std::os::raw::c_uchar, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let a: u8 = unsafe { ::std::mem::transmute(a) }; + a as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 1u8, + { + let b: u8 = unsafe { ::std::mem::transmute(b) }; + b as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 2usize, + 6u8, + { + let c: u8 = unsafe { ::std::mem::transmute(c) }; + c as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 8usize, + 16u8, + { + let d: u16 = unsafe { ::std::mem::transmute(d) }; + d as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 24usize, + 8u8, + { + let e: u8 = unsafe { ::std::mem::transmute(e) }; + e as u64 + }, + ); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Inner { + pub _bindgen_align: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Inner"][::std::mem::size_of::() - 4usize]; + ["Alignment of Inner"][::std::mem::align_of::() - 2usize]; +}; +impl Inner { + #[inline] + pub fn a(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u16) } + } + #[inline] + pub fn set_a(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 16u8, val as u64) + } + } + #[inline] + pub unsafe fn a_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 16u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_a_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 16u8, + val as u64, + ) + } + } + #[inline] + pub fn b(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u16) } + } + #[inline] + pub fn set_b(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 16u8, val as u64) + } + } + #[inline] + pub unsafe fn b_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 16usize, 16u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_b_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 16u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + a: ::std::os::raw::c_ushort, + b: ::std::os::raw::c_ushort, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 16u8, + { + let a: u16 = unsafe { ::std::mem::transmute(a) }; + a as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 16usize, + 16u8, + { + let b: u16 = unsafe { ::std::mem::transmute(b) }; + b as u64 + }, + ); + __bindgen_bitfield_unit + } +} +#[repr(C, packed)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Outer { + pub inner: Inner, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Outer"][::std::mem::size_of::() - 4usize]; + ["Alignment of Outer"][::std::mem::align_of::() - 1usize]; + ["Offset of field: Outer::inner"][::std::mem::offset_of!(Outer, inner) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/block_return_type.rs b/bindgen-tests/tests/expectations/tests/block_return_type.rs new file mode 100644 index 0000000000..8ab2d70f11 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/block_return_type.rs @@ -0,0 +1,10 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +extern crate block; +unsafe extern "C" { + pub fn func() -> _bindgen_ty_id_4; +} +pub type _bindgen_ty_id_4 = *const ::block::Block< + (::std::os::raw::c_int, ::std::os::raw::c_int), + ::std::os::raw::c_int, +>; diff --git a/bindgen-tests/tests/expectations/tests/blocklist-and-impl-debug.rs b/bindgen-tests/tests/expectations/tests/blocklist-and-impl-debug.rs new file mode 100644 index 0000000000..43e645bfc3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/blocklist-and-impl-debug.rs @@ -0,0 +1,33 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub struct BlocklistMe(u8); +/// Because this type contains a blocklisted type, it should not derive Debug. +#[repr(C)] +pub struct ShouldManuallyImplDebug { + pub a: BlocklistMe, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of ShouldManuallyImplDebug", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of ShouldManuallyImplDebug", + ][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: ShouldManuallyImplDebug::a", + ][::std::mem::offset_of!(ShouldManuallyImplDebug, a) - 0usize]; +}; +impl Default for ShouldManuallyImplDebug { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl ::std::fmt::Debug for ShouldManuallyImplDebug { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + write!(f, "ShouldManuallyImplDebug {{ }}") + } +} diff --git a/bindgen-tests/tests/expectations/tests/blocklist-file.rs b/bindgen-tests/tests/expectations/tests/blocklist-file.rs new file mode 100644 index 0000000000..4056ef4d2c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/blocklist-file.rs @@ -0,0 +1,39 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct SizedIntegers { + pub x: u8, + pub y: u16, + pub z: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of SizedIntegers"][::std::mem::size_of::() - 8usize]; + ["Alignment of SizedIntegers"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: SizedIntegers::x", + ][::std::mem::offset_of!(SizedIntegers, x) - 0usize]; + [ + "Offset of field: SizedIntegers::y", + ][::std::mem::offset_of!(SizedIntegers, y) - 2usize]; + [ + "Offset of field: SizedIntegers::z", + ][::std::mem::offset_of!(SizedIntegers, z) - 4usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct StructWithBlocklistedFwdDecl { + pub b: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of StructWithBlocklistedFwdDecl", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of StructWithBlocklistedFwdDecl", + ][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: StructWithBlocklistedFwdDecl::b", + ][::std::mem::offset_of!(StructWithBlocklistedFwdDecl, b) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/blocklist-function.rs b/bindgen-tests/tests/expectations/tests/blocklist-function.rs new file mode 100644 index 0000000000..65b66b2ac2 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/blocklist-function.rs @@ -0,0 +1,28 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod foo { + #[allow(unused_imports)] + use self::super::super::root; + } + pub mod bar { + #[allow(unused_imports)] + use self::super::super::root; + unsafe extern "C" { + #[link_name = "\u{1}_ZN3bar18NamespacedFunctionEv"] + pub fn NamespacedFunction(); + } + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct C { + pub _address: u8, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of C"][::std::mem::size_of::() - 1usize]; + ["Alignment of C"][::std::mem::align_of::() - 1usize]; + }; +} diff --git a/bindgen-tests/tests/expectations/tests/blocklist-item.rs b/bindgen-tests/tests/expectations/tests/blocklist-item.rs new file mode 100644 index 0000000000..c5daf050a1 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/blocklist-item.rs @@ -0,0 +1,18 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod foo { + #[allow(unused_imports)] + use self::super::super::root; + } + pub mod bar { + #[allow(unused_imports)] + use self::super::super::root; + unsafe extern "C" { + #[link_name = "\u{1}_ZN3bar18NamespacedFunctionEv"] + pub fn NamespacedFunction(); + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/blocklist-methods.rs b/bindgen-tests/tests/expectations/tests/blocklist-methods.rs new file mode 100644 index 0000000000..c89cadb3d5 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/blocklist-methods.rs @@ -0,0 +1,21 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN3Foo3fooEv"] + pub fn Foo_foo(this: *mut Foo) -> ::std::os::raw::c_int; +} +impl Foo { + #[inline] + pub unsafe fn foo(&mut self) -> ::std::os::raw::c_int { + Foo_foo(self) + } +} diff --git a/bindgen-tests/tests/expectations/tests/blocklist-var.rs b/bindgen-tests/tests/expectations/tests/blocklist-var.rs new file mode 100644 index 0000000000..fe64295a68 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/blocklist-var.rs @@ -0,0 +1 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] \ No newline at end of file diff --git a/bindgen-tests/tests/expectations/tests/blocklist_bitfield_unit.rs b/bindgen-tests/tests/expectations/tests/blocklist_bitfield_unit.rs new file mode 100644 index 0000000000..77c263e3cc --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/blocklist_bitfield_unit.rs @@ -0,0 +1,118 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[path = "./struct_with_bitfields.rs"] +mod bitfields; +use bitfields::*; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct C { + pub x: ::std::os::raw::c_uchar, + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub baz: ::std::os::raw::c_uint, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C"][::std::mem::size_of::() - 8usize]; + ["Alignment of C"][::std::mem::align_of::() - 4usize]; + ["Offset of field: C::x"][::std::mem::offset_of!(C, x) - 0usize]; + ["Offset of field: C::baz"][::std::mem::offset_of!(C, baz) - 4usize]; +}; +impl C { + #[inline] + pub fn b1(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_b1(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn b1_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_b1_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn b2(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_b2(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn b2_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_b2_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + b1: ::std::os::raw::c_uint, + b2: ::std::os::raw::c_uint, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let b1: u32 = unsafe { ::std::mem::transmute(b1) }; + b1 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 1u8, + { + let b2: u32 = unsafe { ::std::mem::transmute(b2) }; + b2 as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/blocks-signature.rs b/bindgen-tests/tests/expectations/tests/blocks-signature.rs new file mode 100644 index 0000000000..93cf28e009 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/blocks-signature.rs @@ -0,0 +1,66 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +extern crate block; +unsafe extern "C" { + #[link_name = "\u{1}_Z8atexit_bU13block_pointerFvvE"] + pub fn atexit_b(arg1: _bindgen_ty_id_33); +} +pub type dispatch_data_t = *mut ::std::os::raw::c_void; +pub type dispatch_data_applier_t = _bindgen_ty_id_40; +unsafe extern "C" { + #[link_name = "\u{1}_Z19dispatch_data_applyPvU13block_pointerFbS_yPKvyE"] + pub fn dispatch_data_apply( + data: dispatch_data_t, + applier: dispatch_data_applier_t, + ) -> bool; +} +unsafe extern "C" { + #[link_name = "\u{1}_Z3fooU13block_pointerFvyE"] + pub fn foo(arg1: _bindgen_ty_id_50) -> bool; +} +unsafe extern "C" { + #[link_name = "\u{1}_Z7foo_ptrPU13block_pointerFvyE"] + pub fn foo_ptr(arg1: *mut _bindgen_ty_id_56) -> bool; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct contains_block_pointers { + pub val: contains_block_pointers__bindgen_ty_id_61, + pub ptr_val: *mut _bindgen_ty_id_68, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of contains_block_pointers", + ][::std::mem::size_of::() - 16usize]; + [ + "Alignment of contains_block_pointers", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: contains_block_pointers::val", + ][::std::mem::offset_of!(contains_block_pointers, val) - 0usize]; + [ + "Offset of field: contains_block_pointers::ptr_val", + ][::std::mem::offset_of!(contains_block_pointers, ptr_val) - 8usize]; +}; +impl Default for contains_block_pointers { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type _bindgen_ty_id_33 = *const ::block::Block<(), ()>; +pub type _bindgen_ty_id_40 = *const ::block::Block< + (dispatch_data_t, usize, *const ::std::os::raw::c_void, usize), + bool, +>; +pub type _bindgen_ty_id_50 = *const ::block::Block<(usize,), ()>; +pub type _bindgen_ty_id_56 = *const ::block::Block<(usize,), ()>; +pub type contains_block_pointers__bindgen_ty_id_61 = *const ::block::Block< + (::std::os::raw::c_int,), + (), +>; +pub type _bindgen_ty_id_68 = *const ::block::Block<(::std::os::raw::c_int,), ()>; diff --git a/bindgen-tests/tests/expectations/tests/blocks.rs b/bindgen-tests/tests/expectations/tests/blocks.rs new file mode 100644 index 0000000000..4f51113c4b --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/blocks.rs @@ -0,0 +1,53 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +unsafe extern "C" { + #[link_name = "\u{1}_Z8atexit_bU13block_pointerFvvE"] + pub fn atexit_b(arg1: *mut ::std::os::raw::c_void); +} +pub type dispatch_data_t = *mut ::std::os::raw::c_void; +pub type dispatch_data_applier_t = *mut ::std::os::raw::c_void; +unsafe extern "C" { + #[link_name = "\u{1}_Z19dispatch_data_applyPvU13block_pointerFbS_yPKvyE"] + pub fn dispatch_data_apply( + data: dispatch_data_t, + applier: dispatch_data_applier_t, + ) -> bool; +} +unsafe extern "C" { + #[link_name = "\u{1}_Z3fooU13block_pointerFvyE"] + pub fn foo(arg1: *mut ::std::os::raw::c_void) -> bool; +} +unsafe extern "C" { + #[link_name = "\u{1}_Z7foo_ptrPU13block_pointerFvyE"] + pub fn foo_ptr(arg1: *mut *mut ::std::os::raw::c_void) -> bool; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct contains_block_pointers { + pub val: *mut ::std::os::raw::c_void, + pub ptr_val: *mut *mut ::std::os::raw::c_void, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of contains_block_pointers", + ][::std::mem::size_of::() - 16usize]; + [ + "Alignment of contains_block_pointers", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: contains_block_pointers::val", + ][::std::mem::offset_of!(contains_block_pointers, val) - 0usize]; + [ + "Offset of field: contains_block_pointers::ptr_val", + ][::std::mem::offset_of!(contains_block_pointers, ptr_val) - 8usize]; +}; +impl Default for contains_block_pointers { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/bug-1529681.rs b/bindgen-tests/tests/expectations/tests/bug-1529681.rs new file mode 100644 index 0000000000..bd59c1971f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/bug-1529681.rs @@ -0,0 +1,11 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct BrowsingContext { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of BrowsingContext"][::std::mem::size_of::() - 1usize]; + ["Alignment of BrowsingContext"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/builtin-template.rs b/bindgen-tests/tests/expectations/tests/builtin-template.rs new file mode 100644 index 0000000000..53e3fbf9bf --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/builtin-template.rs @@ -0,0 +1,2 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type std_make_integer_sequence = u8; diff --git a/bindgen-tests/tests/expectations/tests/c-empty-layout.rs b/bindgen-tests/tests/expectations/tests/c-empty-layout.rs new file mode 100644 index 0000000000..709a9a59d8 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/c-empty-layout.rs @@ -0,0 +1,9 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo {} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 0usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/c-unwind-abi-override.rs b/bindgen-tests/tests/expectations/tests/c-unwind-abi-override.rs new file mode 100644 index 0000000000..a158565033 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/c-unwind-abi-override.rs @@ -0,0 +1,10 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C-unwind" { + pub fn foo(); +} +unsafe extern "C-unwind" { + pub fn bar(); +} +unsafe extern "C" { + pub fn baz(); +} diff --git a/bindgen-tests/tests/expectations/tests/c_naming.rs b/bindgen-tests/tests/expectations/tests/c_naming.rs new file mode 100644 index 0000000000..38e63ce874 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/c_naming.rs @@ -0,0 +1,47 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct struct_a { + pub a: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of struct_a"][::std::mem::size_of::() - 4usize]; + ["Alignment of struct_a"][::std::mem::align_of::() - 4usize]; + ["Offset of field: struct_a::a"][::std::mem::offset_of!(struct_a, a) - 0usize]; +}; +pub type a = *const struct_a; +#[repr(C)] +#[derive(Copy, Clone)] +pub union union_b { + pub a: ::std::os::raw::c_int, + pub b: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of union_b"][::std::mem::size_of::() - 4usize]; + ["Alignment of union_b"][::std::mem::align_of::() - 4usize]; + ["Offset of field: union_b::a"][::std::mem::offset_of!(union_b, a) - 0usize]; + ["Offset of field: union_b::b"][::std::mem::offset_of!(union_b, b) - 0usize]; +}; +impl Default for union_b { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type b = union_b; +pub const enum_c_A: enum_c = 0; +pub type enum_c = ::std::os::raw::c_uint; +unsafe extern "C" { + pub fn takes_a(arg: a); +} +unsafe extern "C" { + pub fn takes_b(arg: b); +} +unsafe extern "C" { + pub fn takes_c(arg: enum_c); +} diff --git a/bindgen-tests/tests/expectations/tests/call-conv-field.rs b/bindgen-tests/tests/expectations/tests/call-conv-field.rs new file mode 100644 index 0000000000..8f0502a435 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/call-conv-field.rs @@ -0,0 +1,30 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(not(test))] +#[repr(C)] +#[derive(Default, Copy, Clone)] +pub struct JNINativeInterface_ { + pub GetVersion: ::std::option::Option< + unsafe extern "stdcall" fn( + env: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub __hack: ::std::os::raw::c_ulonglong, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of JNINativeInterface_", + ][::std::mem::size_of::() - 16usize]; + [ + "Alignment of JNINativeInterface_", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: JNINativeInterface_::GetVersion", + ][::std::mem::offset_of!(JNINativeInterface_, GetVersion) - 0usize]; + [ + "Offset of field: JNINativeInterface_::__hack", + ][::std::mem::offset_of!(JNINativeInterface_, __hack) - 8usize]; +}; +unsafe extern "stdcall" { + pub fn bar(); +} diff --git a/bindgen-tests/tests/expectations/tests/call-conv-typedef.rs b/bindgen-tests/tests/expectations/tests/call-conv-typedef.rs new file mode 100644 index 0000000000..c62756f364 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/call-conv-typedef.rs @@ -0,0 +1,6 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(not(test))] +pub type void_fn = ::std::option::Option; +pub type fn_ = ::std::option::Option< + unsafe extern "stdcall" fn(id: ::std::os::raw::c_int) -> void_fn, +>; diff --git a/bindgen-tests/tests/expectations/tests/canonical-types.rs b/bindgen-tests/tests/expectations/tests/canonical-types.rs new file mode 100644 index 0000000000..81d2e488a2 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/canonical-types.rs @@ -0,0 +1,193 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct ClassA { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ClassA_ClassAInner { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub x: *mut T, +} +impl Default for ClassA_ClassAInner { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct ClassB { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct ClassC { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ClassC_ClassCInnerB { + pub cache: *mut ClassC_ClassCInnerA, +} +impl Default for ClassC_ClassCInnerB { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ClassC_ClassCInnerA { + pub member: *mut ClassC_ClassCInnerB, +} +impl Default for ClassC_ClassCInnerA { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ClassC_ClassCInnerCRTP { + pub _address: u8, +} +impl Default for ClassC_ClassCInnerCRTP { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ClassD { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ClassD"][::std::mem::size_of::() - 1usize]; + ["Alignment of ClassD"][::std::mem::align_of::() - 1usize]; +}; +impl Default for ClassD { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: ClassB_open0_ClassD_ClassCInnerCRTP_close0", + ][::std::mem::size_of::() - 1usize]; + [ + "Align of template specialization: ClassB_open0_ClassD_ClassCInnerCRTP_close0", + ][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ClassCInnerCRTP { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ClassCInnerCRTP"][::std::mem::size_of::() - 1usize]; + ["Alignment of ClassCInnerCRTP"][::std::mem::align_of::() - 1usize]; +}; +impl Default for ClassCInnerCRTP { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: ClassB_open0_ClassCInnerCRTP_ClassAInner_close0", + ][::std::mem::size_of::() - 1usize]; + [ + "Align of template specialization: ClassB_open0_ClassCInnerCRTP_ClassAInner_close0", + ][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ClassAInner { + pub x: *mut ClassCInnerA, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ClassAInner"][::std::mem::size_of::() - 8usize]; + ["Alignment of ClassAInner"][::std::mem::align_of::() - 8usize]; + ["Offset of field: ClassAInner::x"][::std::mem::offset_of!(ClassAInner, x) - 0usize]; +}; +impl Default for ClassAInner { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ClassCInnerA { + pub member: *mut ClassCInnerB, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ClassCInnerA"][::std::mem::size_of::() - 8usize]; + ["Alignment of ClassCInnerA"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: ClassCInnerA::member", + ][::std::mem::offset_of!(ClassCInnerA, member) - 0usize]; +}; +impl Default for ClassCInnerA { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ClassCInnerB { + pub cache: *mut ClassCInnerA, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ClassCInnerB"][::std::mem::size_of::() - 8usize]; + ["Alignment of ClassCInnerB"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: ClassCInnerB::cache", + ][::std::mem::offset_of!(ClassCInnerB, cache) - 0usize]; +}; +impl Default for ClassCInnerB { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/canonical_path_without_namespacing.rs b/bindgen-tests/tests/expectations/tests/canonical_path_without_namespacing.rs new file mode 100644 index 0000000000..613da3060f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/canonical_path_without_namespacing.rs @@ -0,0 +1,15 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Bar { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 1usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_Z3bazPN3foo3BarE"] + pub fn baz(arg1: *mut Bar); +} diff --git a/bindgen-tests/tests/expectations/tests/char.rs b/bindgen-tests/tests/expectations/tests/char.rs new file mode 100644 index 0000000000..61a81269d7 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/char.rs @@ -0,0 +1,37 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type Char = ::std::os::raw::c_char; +pub type SChar = ::std::os::raw::c_schar; +pub type UChar = ::std::os::raw::c_uchar; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Test { + pub ch: ::std::os::raw::c_char, + pub u: ::std::os::raw::c_uchar, + pub d: ::std::os::raw::c_schar, + pub cch: ::std::os::raw::c_char, + pub cu: ::std::os::raw::c_uchar, + pub cd: ::std::os::raw::c_schar, + pub Cch: Char, + pub Cu: UChar, + pub Cd: SChar, + pub Ccch: Char, + pub Ccu: UChar, + pub Ccd: SChar, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Test"][::std::mem::size_of::() - 12usize]; + ["Alignment of Test"][::std::mem::align_of::() - 1usize]; + ["Offset of field: Test::ch"][::std::mem::offset_of!(Test, ch) - 0usize]; + ["Offset of field: Test::u"][::std::mem::offset_of!(Test, u) - 1usize]; + ["Offset of field: Test::d"][::std::mem::offset_of!(Test, d) - 2usize]; + ["Offset of field: Test::cch"][::std::mem::offset_of!(Test, cch) - 3usize]; + ["Offset of field: Test::cu"][::std::mem::offset_of!(Test, cu) - 4usize]; + ["Offset of field: Test::cd"][::std::mem::offset_of!(Test, cd) - 5usize]; + ["Offset of field: Test::Cch"][::std::mem::offset_of!(Test, Cch) - 6usize]; + ["Offset of field: Test::Cu"][::std::mem::offset_of!(Test, Cu) - 7usize]; + ["Offset of field: Test::Cd"][::std::mem::offset_of!(Test, Cd) - 8usize]; + ["Offset of field: Test::Ccch"][::std::mem::offset_of!(Test, Ccch) - 9usize]; + ["Offset of field: Test::Ccu"][::std::mem::offset_of!(Test, Ccu) - 10usize]; + ["Offset of field: Test::Ccd"][::std::mem::offset_of!(Test, Ccd) - 11usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/char16_t.rs b/bindgen-tests/tests/expectations/tests/char16_t.rs new file mode 100644 index 0000000000..82d30fe517 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/char16_t.rs @@ -0,0 +1,7 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(transparent)] +pub struct bindgen_cchar16_t(u16); +unsafe extern "C" { + #[link_name = "\u{1}_Z16receive_char16_tDs"] + pub fn receive_char16_t(input: bindgen_cchar16_t); +} diff --git a/bindgen-tests/tests/expectations/tests/class.rs b/bindgen-tests/tests/expectations/tests/class.rs new file mode 100644 index 0000000000..98ee43b374 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/class.rs @@ -0,0 +1,377 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Default)] +pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); +impl __IncompleteArrayField { + #[inline] + pub const fn new() -> Self { + __IncompleteArrayField(::std::marker::PhantomData, []) + } + #[inline] + pub fn as_ptr(&self) -> *const T { + self as *const _ as *const T + } + #[inline] + pub fn as_mut_ptr(&mut self) -> *mut T { + self as *mut _ as *mut T + } + #[inline] + pub unsafe fn as_slice(&self, len: usize) -> &[T] { + ::std::slice::from_raw_parts(self.as_ptr(), len) + } + #[inline] + pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { + ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) + } +} +impl ::std::fmt::Debug for __IncompleteArrayField { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + fmt.write_str("__IncompleteArrayField") + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)] +pub struct C { + pub a: ::std::os::raw::c_int, + pub big_array: [::std::os::raw::c_char; 33usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C"][::std::mem::size_of::() - 40usize]; + ["Alignment of C"][::std::mem::align_of::() - 4usize]; + ["Offset of field: C::a"][::std::mem::offset_of!(C, a) - 0usize]; + ["Offset of field: C::big_array"][::std::mem::offset_of!(C, big_array) - 4usize]; +}; +impl Default for C { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug)] +pub struct C_with_zero_length_array { + pub a: ::std::os::raw::c_int, + pub big_array: [::std::os::raw::c_char; 33usize], + pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of C_with_zero_length_array", + ][::std::mem::size_of::() - 40usize]; + [ + "Alignment of C_with_zero_length_array", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: C_with_zero_length_array::a", + ][::std::mem::offset_of!(C_with_zero_length_array, a) - 0usize]; + [ + "Offset of field: C_with_zero_length_array::big_array", + ][::std::mem::offset_of!(C_with_zero_length_array, big_array) - 4usize]; + [ + "Offset of field: C_with_zero_length_array::zero_length_array", + ][::std::mem::offset_of!(C_with_zero_length_array, zero_length_array) - 37usize]; +}; +impl Default for C_with_zero_length_array { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default)] +pub struct C_with_zero_length_array_2 { + pub a: ::std::os::raw::c_int, + pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of C_with_zero_length_array_2", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of C_with_zero_length_array_2", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: C_with_zero_length_array_2::a", + ][::std::mem::offset_of!(C_with_zero_length_array_2, a) - 0usize]; + [ + "Offset of field: C_with_zero_length_array_2::zero_length_array", + ][::std::mem::offset_of!(C_with_zero_length_array_2, zero_length_array) - 4usize]; +}; +#[repr(C)] +#[derive(Debug)] +pub struct C_with_incomplete_array { + pub a: ::std::os::raw::c_int, + pub big_array: [::std::os::raw::c_char; 33usize], + pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of C_with_incomplete_array", + ][::std::mem::size_of::() - 40usize]; + [ + "Alignment of C_with_incomplete_array", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: C_with_incomplete_array::a", + ][::std::mem::offset_of!(C_with_incomplete_array, a) - 0usize]; + [ + "Offset of field: C_with_incomplete_array::big_array", + ][::std::mem::offset_of!(C_with_incomplete_array, big_array) - 4usize]; + [ + "Offset of field: C_with_incomplete_array::incomplete_array", + ][::std::mem::offset_of!(C_with_incomplete_array, incomplete_array) - 37usize]; +}; +impl Default for C_with_incomplete_array { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default)] +pub struct C_with_incomplete_array_2 { + pub a: ::std::os::raw::c_int, + pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of C_with_incomplete_array_2", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of C_with_incomplete_array_2", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: C_with_incomplete_array_2::a", + ][::std::mem::offset_of!(C_with_incomplete_array_2, a) - 0usize]; + [ + "Offset of field: C_with_incomplete_array_2::incomplete_array", + ][::std::mem::offset_of!(C_with_incomplete_array_2, incomplete_array) - 4usize]; +}; +#[repr(C)] +#[derive(Debug)] +pub struct C_with_zero_length_array_and_incomplete_array { + pub a: ::std::os::raw::c_int, + pub big_array: [::std::os::raw::c_char; 33usize], + pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>, + pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of C_with_zero_length_array_and_incomplete_array", + ][::std::mem::size_of::() - 40usize]; + [ + "Alignment of C_with_zero_length_array_and_incomplete_array", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: C_with_zero_length_array_and_incomplete_array::a", + ][::std::mem::offset_of!(C_with_zero_length_array_and_incomplete_array, a) - 0usize]; + [ + "Offset of field: C_with_zero_length_array_and_incomplete_array::big_array", + ][::std::mem::offset_of!(C_with_zero_length_array_and_incomplete_array, big_array) + - 4usize]; + [ + "Offset of field: C_with_zero_length_array_and_incomplete_array::zero_length_array", + ][::std::mem::offset_of!( + C_with_zero_length_array_and_incomplete_array, zero_length_array + ) - 37usize]; + [ + "Offset of field: C_with_zero_length_array_and_incomplete_array::incomplete_array", + ][::std::mem::offset_of!( + C_with_zero_length_array_and_incomplete_array, incomplete_array + ) - 37usize]; +}; +impl Default for C_with_zero_length_array_and_incomplete_array { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default)] +pub struct C_with_zero_length_array_and_incomplete_array_2 { + pub a: ::std::os::raw::c_int, + pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>, + pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of C_with_zero_length_array_and_incomplete_array_2", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of C_with_zero_length_array_and_incomplete_array_2", + ][::std::mem::align_of::() + - 4usize]; + [ + "Offset of field: C_with_zero_length_array_and_incomplete_array_2::a", + ][::std::mem::offset_of!(C_with_zero_length_array_and_incomplete_array_2, a) + - 0usize]; + [ + "Offset of field: C_with_zero_length_array_and_incomplete_array_2::zero_length_array", + ][::std::mem::offset_of!( + C_with_zero_length_array_and_incomplete_array_2, zero_length_array + ) - 4usize]; + [ + "Offset of field: C_with_zero_length_array_and_incomplete_array_2::incomplete_array", + ][::std::mem::offset_of!( + C_with_zero_length_array_and_incomplete_array_2, incomplete_array + ) - 4usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Hash, PartialOrd, Ord, PartialEq, Eq)] +pub struct WithDtor { + pub b: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of WithDtor"][::std::mem::size_of::() - 4usize]; + ["Alignment of WithDtor"][::std::mem::align_of::() - 4usize]; + ["Offset of field: WithDtor::b"][::std::mem::offset_of!(WithDtor, b) - 0usize]; +}; +#[repr(C)] +#[derive(Debug)] +pub struct IncompleteArrayNonCopiable { + pub whatever: *mut ::std::os::raw::c_void, + pub incomplete_array: __IncompleteArrayField, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of IncompleteArrayNonCopiable", + ][::std::mem::size_of::() - 8usize]; + [ + "Alignment of IncompleteArrayNonCopiable", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: IncompleteArrayNonCopiable::whatever", + ][::std::mem::offset_of!(IncompleteArrayNonCopiable, whatever) - 0usize]; + [ + "Offset of field: IncompleteArrayNonCopiable::incomplete_array", + ][::std::mem::offset_of!(IncompleteArrayNonCopiable, incomplete_array) - 8usize]; +}; +impl Default for IncompleteArrayNonCopiable { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Union { + pub d: f32, + pub i: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Union"][::std::mem::size_of::() - 4usize]; + ["Alignment of Union"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Union::d"][::std::mem::offset_of!(Union, d) - 0usize]; + ["Offset of field: Union::i"][::std::mem::offset_of!(Union, i) - 0usize]; +}; +impl Default for Union { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct WithUnion { + pub data: Union, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of WithUnion"][::std::mem::size_of::() - 4usize]; + ["Alignment of WithUnion"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: WithUnion::data", + ][::std::mem::offset_of!(WithUnion, data) - 0usize]; +}; +impl Default for WithUnion { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)] +pub struct RealAbstractionWithTonsOfMethods { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of RealAbstractionWithTonsOfMethods", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of RealAbstractionWithTonsOfMethods", + ][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZNK32RealAbstractionWithTonsOfMethods3barEv"] + pub fn RealAbstractionWithTonsOfMethods_bar( + this: *const RealAbstractionWithTonsOfMethods, + ); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3barEv"] + pub fn RealAbstractionWithTonsOfMethods_bar1( + this: *mut RealAbstractionWithTonsOfMethods, + ); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3barEi"] + pub fn RealAbstractionWithTonsOfMethods_bar2( + this: *mut RealAbstractionWithTonsOfMethods, + foo: ::std::os::raw::c_int, + ); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3staEv"] + pub fn RealAbstractionWithTonsOfMethods_sta(); +} +impl RealAbstractionWithTonsOfMethods { + #[inline] + pub unsafe fn bar(&self) { + RealAbstractionWithTonsOfMethods_bar(self) + } + #[inline] + pub unsafe fn bar1(&mut self) { + RealAbstractionWithTonsOfMethods_bar1(self) + } + #[inline] + pub unsafe fn bar2(&mut self, foo: ::std::os::raw::c_int) { + RealAbstractionWithTonsOfMethods_bar2(self, foo) + } + #[inline] + pub unsafe fn sta() { + RealAbstractionWithTonsOfMethods_sta() + } +} diff --git a/bindgen-tests/tests/expectations/tests/class_nested.rs b/bindgen-tests/tests/expectations/tests/class_nested.rs new file mode 100644 index 0000000000..080f5968bc --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/class_nested.rs @@ -0,0 +1,105 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct A { + pub member_a: ::std::os::raw::c_int, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct A_B { + pub member_b: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A_B"][::std::mem::size_of::() - 4usize]; + ["Alignment of A_B"][::std::mem::align_of::() - 4usize]; + ["Offset of field: A_B::member_b"][::std::mem::offset_of!(A_B, member_b) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct A_D { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub foo: T, +} +impl Default for A_D { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A"][::std::mem::size_of::() - 4usize]; + ["Alignment of A"][::std::mem::align_of::() - 4usize]; + ["Offset of field: A::member_a"][::std::mem::offset_of!(A, member_a) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct A_C { + pub baz: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A_C"][::std::mem::size_of::() - 4usize]; + ["Alignment of A_C"][::std::mem::align_of::() - 4usize]; + ["Offset of field: A_C::baz"][::std::mem::offset_of!(A_C, baz) - 0usize]; +}; +unsafe extern "C" { + pub static mut var: A_B; +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: A_D_open0_int_close0", + ][::std::mem::size_of::>() - 4usize]; + [ + "Align of template specialization: A_D_open0_int_close0", + ][::std::mem::align_of::>() - 4usize]; +}; +unsafe extern "C" { + pub static mut baz: A_D<::std::os::raw::c_int>; +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct D { + pub member: A_B, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of D"][::std::mem::size_of::() - 4usize]; + ["Alignment of D"][::std::mem::align_of::() - 4usize]; + ["Offset of field: D::member"][::std::mem::offset_of!(D, member) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Templated { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub member: T, +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Templated_Templated_inner { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub member_ptr: *mut T, +} +impl Default for Templated_Templated_inner { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Default for Templated { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/class_no_members.rs b/bindgen-tests/tests/expectations/tests/class_no_members.rs new file mode 100644 index 0000000000..c50da6a02d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/class_no_members.rs @@ -0,0 +1,38 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct whatever { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of whatever"][::std::mem::size_of::() - 1usize]; + ["Alignment of whatever"][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct whatever_child { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of whatever_child"][::std::mem::size_of::() - 1usize]; + ["Alignment of whatever_child"][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct whatever_child_with_member { + pub m_member: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of whatever_child_with_member", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of whatever_child_with_member", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: whatever_child_with_member::m_member", + ][::std::mem::offset_of!(whatever_child_with_member, m_member) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/class_static.rs b/bindgen-tests/tests/expectations/tests/class_static.rs new file mode 100644 index 0000000000..d448165d62 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/class_static.rs @@ -0,0 +1,23 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct MyClass { + pub _address: u8, +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN7MyClass7exampleE"] + pub static mut MyClass_example: *const ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN7MyClass26example_check_no_collisionE"] + pub static mut MyClass_example_check_no_collision: *const ::std::os::raw::c_int; +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of MyClass"][::std::mem::size_of::() - 1usize]; + ["Alignment of MyClass"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZL26example_check_no_collision"] + pub static mut example_check_no_collision: *const ::std::os::raw::c_int; +} diff --git a/bindgen-tests/tests/expectations/tests/class_static_const.rs b/bindgen-tests/tests/expectations/tests/class_static_const.rs new file mode 100644 index 0000000000..d628239c4c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/class_static_const.rs @@ -0,0 +1,14 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct A { + pub _address: u8, +} +pub const A_a: ::std::os::raw::c_int = 0; +pub const A_b: i32 = 63; +pub const A_c: u32 = 255; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A"][::std::mem::size_of::() - 1usize]; + ["Alignment of A"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/class_use_as.rs b/bindgen-tests/tests/expectations/tests/class_use_as.rs new file mode 100644 index 0000000000..ec898ff7eb --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/class_use_as.rs @@ -0,0 +1,26 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +///
+#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct whatever { + pub replacement: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of whatever"][::std::mem::size_of::() - 4usize]; + ["Alignment of whatever"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: whatever::replacement", + ][::std::mem::offset_of!(whatever, replacement) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct container { + pub c: whatever, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of container"][::std::mem::size_of::() - 4usize]; + ["Alignment of container"][::std::mem::align_of::() - 4usize]; + ["Offset of field: container::c"][::std::mem::offset_of!(container, c) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/class_with_dtor.rs b/bindgen-tests/tests/expectations/tests/class_with_dtor.rs new file mode 100644 index 0000000000..aa99f42468 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/class_with_dtor.rs @@ -0,0 +1,48 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Hash, PartialEq, Eq)] +pub struct HandleWithDtor { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub ptr: *mut T, +} +impl Default for HandleWithDtor { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type HandleValue = HandleWithDtor<::std::os::raw::c_int>; +#[repr(C)] +#[derive(Debug, Hash, PartialEq, Eq)] +pub struct WithoutDtor { + pub shouldBeWithDtor: HandleValue, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of WithoutDtor"][::std::mem::size_of::() - 8usize]; + ["Alignment of WithoutDtor"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: WithoutDtor::shouldBeWithDtor", + ][::std::mem::offset_of!(WithoutDtor, shouldBeWithDtor) - 0usize]; +}; +impl Default for WithoutDtor { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: HandleWithDtor_open0_int_close0", + ][::std::mem::size_of::>() - 8usize]; + [ + "Align of template specialization: HandleWithDtor_open0_int_close0", + ][::std::mem::align_of::>() - 8usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/class_with_enum.rs b/bindgen-tests/tests/expectations/tests/class_with_enum.rs new file mode 100644 index 0000000000..ca1806357c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/class_with_enum.rs @@ -0,0 +1,14 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct A { + pub _address: u8, +} +pub const A_B_B1: A_B = 0; +pub const A_B_B2: A_B = 1; +pub type A_B = ::std::os::raw::c_uint; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A"][::std::mem::size_of::() - 1usize]; + ["Alignment of A"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/class_with_inner_struct.rs b/bindgen-tests/tests/expectations/tests/class_with_inner_struct.rs new file mode 100644 index 0000000000..710026c72f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/class_with_inner_struct.rs @@ -0,0 +1,235 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct A { + pub c: ::std::os::raw::c_uint, + pub named_union: A__bindgen_ty_1, + pub __bindgen_anon_1: A__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct A_Segment { + pub begin: ::std::os::raw::c_int, + pub end: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A_Segment"][::std::mem::size_of::() - 8usize]; + ["Alignment of A_Segment"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: A_Segment::begin", + ][::std::mem::offset_of!(A_Segment, begin) - 0usize]; + ["Offset of field: A_Segment::end"][::std::mem::offset_of!(A_Segment, end) - 4usize]; +}; +#[repr(C)] +#[derive(Copy, Clone)] +pub union A__bindgen_ty_1 { + pub f: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A__bindgen_ty_1"][::std::mem::size_of::() - 4usize]; + ["Alignment of A__bindgen_ty_1"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: A__bindgen_ty_1::f", + ][::std::mem::offset_of!(A__bindgen_ty_1, f) - 0usize]; +}; +impl Default for A__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union A__bindgen_ty_2 { + pub d: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A__bindgen_ty_2"][::std::mem::size_of::() - 4usize]; + ["Alignment of A__bindgen_ty_2"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: A__bindgen_ty_2::d", + ][::std::mem::offset_of!(A__bindgen_ty_2, d) - 0usize]; +}; +impl Default for A__bindgen_ty_2 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A"][::std::mem::size_of::() - 12usize]; + ["Alignment of A"][::std::mem::align_of::() - 4usize]; + ["Offset of field: A::c"][::std::mem::offset_of!(A, c) - 0usize]; + ["Offset of field: A::named_union"][::std::mem::offset_of!(A, named_union) - 4usize]; +}; +impl Default for A { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct B { + pub d: ::std::os::raw::c_uint, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct B_Segment { + pub begin: ::std::os::raw::c_int, + pub end: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of B_Segment"][::std::mem::size_of::() - 8usize]; + ["Alignment of B_Segment"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: B_Segment::begin", + ][::std::mem::offset_of!(B_Segment, begin) - 0usize]; + ["Offset of field: B_Segment::end"][::std::mem::offset_of!(B_Segment, end) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of B"][::std::mem::size_of::() - 4usize]; + ["Alignment of B"][::std::mem::align_of::() - 4usize]; + ["Offset of field: B::d"][::std::mem::offset_of!(B, d) - 0usize]; +}; +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum StepSyntax { + Keyword = 0, + FunctionalWithoutKeyword = 1, + FunctionalWithStartKeyword = 2, + FunctionalWithEndKeyword = 3, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct C { + pub d: ::std::os::raw::c_uint, + pub __bindgen_anon_1: C__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union C__bindgen_ty_1 { + pub mFunc: C__bindgen_ty_1__bindgen_ty_1, + pub __bindgen_anon_1: C__bindgen_ty_1__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, PartialEq)] +pub struct C__bindgen_ty_1__bindgen_ty_1 { + pub mX1: f32, + pub mY1: f32, + pub mX2: f32, + pub mY2: f32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of C__bindgen_ty_1__bindgen_ty_1", + ][::std::mem::size_of::() - 16usize]; + [ + "Alignment of C__bindgen_ty_1__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: C__bindgen_ty_1__bindgen_ty_1::mX1", + ][::std::mem::offset_of!(C__bindgen_ty_1__bindgen_ty_1, mX1) - 0usize]; + [ + "Offset of field: C__bindgen_ty_1__bindgen_ty_1::mY1", + ][::std::mem::offset_of!(C__bindgen_ty_1__bindgen_ty_1, mY1) - 4usize]; + [ + "Offset of field: C__bindgen_ty_1__bindgen_ty_1::mX2", + ][::std::mem::offset_of!(C__bindgen_ty_1__bindgen_ty_1, mX2) - 8usize]; + [ + "Offset of field: C__bindgen_ty_1__bindgen_ty_1::mY2", + ][::std::mem::offset_of!(C__bindgen_ty_1__bindgen_ty_1, mY2) - 12usize]; +}; +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct C__bindgen_ty_1__bindgen_ty_2 { + pub mStepSyntax: StepSyntax, + pub mSteps: ::std::os::raw::c_uint, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of C__bindgen_ty_1__bindgen_ty_2", + ][::std::mem::size_of::() - 8usize]; + [ + "Alignment of C__bindgen_ty_1__bindgen_ty_2", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: C__bindgen_ty_1__bindgen_ty_2::mStepSyntax", + ][::std::mem::offset_of!(C__bindgen_ty_1__bindgen_ty_2, mStepSyntax) - 0usize]; + [ + "Offset of field: C__bindgen_ty_1__bindgen_ty_2::mSteps", + ][::std::mem::offset_of!(C__bindgen_ty_1__bindgen_ty_2, mSteps) - 4usize]; +}; +impl Default for C__bindgen_ty_1__bindgen_ty_2 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C__bindgen_ty_1"][::std::mem::size_of::() - 16usize]; + ["Alignment of C__bindgen_ty_1"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: C__bindgen_ty_1::mFunc", + ][::std::mem::offset_of!(C__bindgen_ty_1, mFunc) - 0usize]; +}; +impl Default for C__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct C_Segment { + pub begin: ::std::os::raw::c_int, + pub end: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C_Segment"][::std::mem::size_of::() - 8usize]; + ["Alignment of C_Segment"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: C_Segment::begin", + ][::std::mem::offset_of!(C_Segment, begin) - 0usize]; + ["Offset of field: C_Segment::end"][::std::mem::offset_of!(C_Segment, end) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C"][::std::mem::size_of::() - 20usize]; + ["Alignment of C"][::std::mem::align_of::() - 4usize]; + ["Offset of field: C::d"][::std::mem::offset_of!(C, d) - 0usize]; +}; +impl Default for C { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/class_with_typedef.rs b/bindgen-tests/tests/expectations/tests/class_with_typedef.rs new file mode 100644 index 0000000000..73f2b55cc3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/class_with_typedef.rs @@ -0,0 +1,87 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type AnotherInt = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct C { + pub c: C_MyInt, + pub ptr: *mut C_MyInt, + pub arr: [C_MyInt; 10usize], + pub d: AnotherInt, + pub other_ptr: *mut AnotherInt, +} +pub type C_MyInt = ::std::os::raw::c_int; +pub type C_Lookup = *const ::std::os::raw::c_char; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C"][::std::mem::size_of::() - 72usize]; + ["Alignment of C"][::std::mem::align_of::() - 8usize]; + ["Offset of field: C::c"][::std::mem::offset_of!(C, c) - 0usize]; + ["Offset of field: C::ptr"][::std::mem::offset_of!(C, ptr) - 8usize]; + ["Offset of field: C::arr"][::std::mem::offset_of!(C, arr) - 16usize]; + ["Offset of field: C::d"][::std::mem::offset_of!(C, d) - 56usize]; + ["Offset of field: C::other_ptr"][::std::mem::offset_of!(C, other_ptr) - 64usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN1C6methodEi"] + pub fn C_method(this: *mut C, c: C_MyInt); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN1C9methodRefERi"] + pub fn C_methodRef(this: *mut C, c: *mut C_MyInt); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN1C16complexMethodRefERPKc"] + pub fn C_complexMethodRef(this: *mut C, c: *mut C_Lookup); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN1C13anotherMethodEi"] + pub fn C_anotherMethod(this: *mut C, c: AnotherInt); +} +impl Default for C { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl C { + #[inline] + pub unsafe fn method(&mut self, c: C_MyInt) { + C_method(self, c) + } + #[inline] + pub unsafe fn methodRef(&mut self, c: *mut C_MyInt) { + C_methodRef(self, c) + } + #[inline] + pub unsafe fn complexMethodRef(&mut self, c: *mut C_Lookup) { + C_complexMethodRef(self, c) + } + #[inline] + pub unsafe fn anotherMethod(&mut self, c: AnotherInt) { + C_anotherMethod(self, c) + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct D { + pub _base: C, + pub ptr: *mut C_MyInt, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of D"][::std::mem::size_of::() - 80usize]; + ["Alignment of D"][::std::mem::align_of::() - 8usize]; + ["Offset of field: D::ptr"][::std::mem::offset_of!(D, ptr) - 72usize]; +}; +impl Default for D { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/comment-indent.rs b/bindgen-tests/tests/expectations/tests/comment-indent.rs new file mode 100644 index 0000000000..72b167d00c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/comment-indent.rs @@ -0,0 +1,81 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + /** This is a multi-line doc comment. + + This class is really really interesting, look!*/ + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Foo { + pub _address: u8, + } + /** This nested class is also a multi-line doc comment. + + This class is not so interesting, but worth a bit of docs too!*/ + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Foo_Bar { + pub _address: u8, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Foo_Bar"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo_Bar"][::std::mem::align_of::() - 1usize]; + }; + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; + }; + pub mod test { + #[allow(unused_imports)] + use self::super::super::root; + /** I'm in a namespace, and thus I may be on a rust module, most of the time. + My documentation is pretty extensive, I guess.*/ + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Baz { + /** This member is plain awesome, just amazing. + + It also has super-extensive docs, with even a nice ascii-art diagram. + + +------+ +-------+ + | foo | ----> | bar | + +------+ +-------+*/ + pub member: ::std::os::raw::c_int, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Baz"][::std::mem::size_of::() - 4usize]; + ["Alignment of Baz"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: Baz::member", + ][::std::mem::offset_of!(Baz, member) - 0usize]; + }; + /** I'm in an inline namespace, and as such I shouldn't get generated inside + a rust module, except when the relevant option is specified. Also, this + comment shouldn't be misaligned.*/ + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct InInlineNS { + pub _address: u8, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of InInlineNS"][::std::mem::size_of::() - 1usize]; + ["Alignment of InInlineNS"][::std::mem::align_of::() - 1usize]; + }; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Bazz { + pub _address: u8, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Bazz"][::std::mem::size_of::() - 1usize]; + ["Alignment of Bazz"][::std::mem::align_of::() - 1usize]; + }; + } +} diff --git a/bindgen-tests/tests/expectations/tests/complex.rs b/bindgen-tests/tests/expectations/tests/complex.rs new file mode 100644 index 0000000000..233b86ea36 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/complex.rs @@ -0,0 +1,77 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[derive(PartialEq, Copy, Clone, Hash, Debug, Default)] +#[repr(C)] +pub struct __BindgenComplex { + pub re: T, + pub im: T, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, PartialEq)] +pub struct TestDouble { + pub mMember: __BindgenComplex, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of TestDouble"][::std::mem::size_of::() - 16usize]; + ["Alignment of TestDouble"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: TestDouble::mMember", + ][::std::mem::offset_of!(TestDouble, mMember) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct TestDoublePtr { + pub mMember: *mut __BindgenComplex, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of TestDoublePtr"][::std::mem::size_of::() - 8usize]; + ["Alignment of TestDoublePtr"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: TestDoublePtr::mMember", + ][::std::mem::offset_of!(TestDoublePtr, mMember) - 0usize]; +}; +impl Default for TestDoublePtr { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, PartialEq)] +pub struct TestFloat { + pub mMember: __BindgenComplex, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of TestFloat"][::std::mem::size_of::() - 8usize]; + ["Alignment of TestFloat"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: TestFloat::mMember", + ][::std::mem::offset_of!(TestFloat, mMember) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct TestFloatPtr { + pub mMember: *mut __BindgenComplex, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of TestFloatPtr"][::std::mem::size_of::() - 8usize]; + ["Alignment of TestFloatPtr"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: TestFloatPtr::mMember", + ][::std::mem::offset_of!(TestFloatPtr, mMember) - 0usize]; +}; +impl Default for TestFloatPtr { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/complex_global.rs b/bindgen-tests/tests/expectations/tests/complex_global.rs new file mode 100644 index 0000000000..c818df676e --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/complex_global.rs @@ -0,0 +1,16 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[derive(PartialEq, Copy, Clone, Hash, Debug, Default)] +#[repr(C)] +pub struct __BindgenComplex { + pub re: T, + pub im: T, +} +unsafe extern "C" { + pub static mut globalValueFloat: __BindgenComplex; +} +unsafe extern "C" { + pub static mut globalValueDouble: __BindgenComplex; +} +unsafe extern "C" { + pub static mut globalValueLongDouble: __BindgenComplex; +} diff --git a/bindgen-tests/tests/expectations/tests/const-const-mut-ptr.rs b/bindgen-tests/tests/expectations/tests/const-const-mut-ptr.rs new file mode 100644 index 0000000000..72a34da105 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/const-const-mut-ptr.rs @@ -0,0 +1,21 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct foo { + pub bar: *const *const *mut *const ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 8usize]; + ["Alignment of foo"][::std::mem::align_of::() - 8usize]; + ["Offset of field: foo::bar"][::std::mem::offset_of!(foo, bar) - 0usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/const_array.rs b/bindgen-tests/tests/expectations/tests/const_array.rs new file mode 100644 index 0000000000..30852deb36 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/const_array.rs @@ -0,0 +1,7 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub static foo: [::std::os::raw::c_int; 1usize]; +} +unsafe extern "C" { + pub static mut bar: [::std::os::raw::c_int; 1usize]; +} diff --git a/bindgen-tests/tests/expectations/tests/const_array_fn_arg.rs b/bindgen-tests/tests/expectations/tests/const_array_fn_arg.rs new file mode 100644 index 0000000000..fb26311115 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/const_array_fn_arg.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn f(a: *const ::std::os::raw::c_int); +} diff --git a/bindgen-tests/tests/expectations/tests/const_array_typedef.rs b/bindgen-tests/tests/expectations/tests/const_array_typedef.rs new file mode 100644 index 0000000000..034856d359 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/const_array_typedef.rs @@ -0,0 +1,28 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct strct { + pub field: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of strct"][::std::mem::size_of::() - 4usize]; + ["Alignment of strct"][::std::mem::align_of::() - 4usize]; + ["Offset of field: strct::field"][::std::mem::offset_of!(strct, field) - 0usize]; +}; +pub type typ = [strct; 1usize]; +unsafe extern "C" { + pub static mut w: typ; +} +unsafe extern "C" { + pub static mut x: *mut strct; +} +unsafe extern "C" { + pub static y: typ; +} +unsafe extern "C" { + pub static mut z: *const strct; +} +unsafe extern "C" { + pub fn function(a: *const strct, b: *const strct); +} diff --git a/bindgen-tests/tests/expectations/tests/const_bool.rs b/bindgen-tests/tests/expectations/tests/const_bool.rs new file mode 100644 index 0000000000..2cbab47390 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/const_bool.rs @@ -0,0 +1,15 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const k: bool = true; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct A { + pub _address: u8, +} +pub const A_k: bool = false; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A"][::std::mem::size_of::() - 1usize]; + ["Alignment of A"][::std::mem::align_of::() - 1usize]; +}; +pub type foo = bool; +pub const k2: foo = true; diff --git a/bindgen-tests/tests/expectations/tests/const_enum_unnamed.rs b/bindgen-tests/tests/expectations/tests/const_enum_unnamed.rs new file mode 100644 index 0000000000..f49d825224 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/const_enum_unnamed.rs @@ -0,0 +1,25 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const FOO_BAR: _bindgen_ty_1 = _bindgen_ty_1::FOO_BAR; +pub const FOO_BAZ: _bindgen_ty_1 = _bindgen_ty_1::FOO_BAZ; +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _bindgen_ty_1 { + FOO_BAR = 0, + FOO_BAZ = 1, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +pub const Foo_FOO_BAR: Foo__bindgen_ty_1 = Foo__bindgen_ty_1::FOO_BAR; +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum Foo__bindgen_ty_1 { + FOO_BAR = 10, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/const_multidim_array_fn_arg.rs b/bindgen-tests/tests/expectations/tests/const_multidim_array_fn_arg.rs new file mode 100644 index 0000000000..db0ce114fb --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/const_multidim_array_fn_arg.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn f(a: *const [::std::os::raw::c_int; 1usize]); +} diff --git a/bindgen-tests/tests/expectations/tests/const_ptr.rs b/bindgen-tests/tests/expectations/tests/const_ptr.rs new file mode 100644 index 0000000000..9b9e38c1e7 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/const_ptr.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn foo(bar: *const ::std::os::raw::c_void); +} diff --git a/bindgen-tests/tests/expectations/tests/const_resolved_ty.rs b/bindgen-tests/tests/expectations/tests/const_resolved_ty.rs new file mode 100644 index 0000000000..ed49b69f64 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/const_resolved_ty.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn foo(foo: *const u8); +} diff --git a/bindgen-tests/tests/expectations/tests/const_tparam.rs b/bindgen-tests/tests/expectations/tests/const_tparam.rs new file mode 100644 index 0000000000..c6b16a8959 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/const_tparam.rs @@ -0,0 +1,17 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct C { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub foo: *const T, + pub bar: *const T, +} +impl Default for C { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/constant-evaluate.rs b/bindgen-tests/tests/expectations/tests/constant-evaluate.rs new file mode 100644 index 0000000000..bbcf6d5450 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/constant-evaluate.rs @@ -0,0 +1,19 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const foo: _bindgen_ty_1 = _bindgen_ty_1::foo; +pub const bar: _bindgen_ty_1 = _bindgen_ty_1::bar; +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _bindgen_ty_1 { + foo = 4, + bar = 8, +} +pub type EasyToOverflow = ::std::os::raw::c_ulonglong; +pub const k: EasyToOverflow = 2147483648; +pub const k_expr: EasyToOverflow = 1152921504606846976; +pub const wow: EasyToOverflow = 2147483648; +pub const BAZ: ::std::os::raw::c_longlong = 24; +pub const fuzz: f64 = 51.0; +pub const BAZZ: ::std::os::raw::c_char = 53; +pub const WAT: ::std::os::raw::c_char = 0; +pub const bytestring: &[u8; 4] = b"Foo\0"; +pub const NOT_UTF8: &[u8; 5] = b"\xF0(\x8C(\0"; diff --git a/bindgen-tests/tests/expectations/tests/constant-non-specialized-tp.rs b/bindgen-tests/tests/expectations/tests/constant-non-specialized-tp.rs new file mode 100644 index 0000000000..968ec350aa --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/constant-non-specialized-tp.rs @@ -0,0 +1,16 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Test { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Outer { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Outer_Inner { + pub _address: u8, +} diff --git a/bindgen-tests/tests/expectations/tests/constified-enum-module-overflow.rs b/bindgen-tests/tests/expectations/tests/constified-enum-module-overflow.rs new file mode 100644 index 0000000000..e5eada9abc --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/constified-enum-module-overflow.rs @@ -0,0 +1,41 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct B { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct C { + pub _address: u8, +} +pub type C_U = B; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct A { + pub u: B, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A"][::std::mem::size_of::() - 1usize]; + ["Alignment of A"][::std::mem::align_of::() - 1usize]; + ["Offset of field: A::u"][::std::mem::offset_of!(A, u) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: C_open0_A_close0", + ][::std::mem::size_of::() - 1usize]; + [ + "Align of template specialization: C_open0_A_close0", + ][::std::mem::align_of::() - 1usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: B_open0_A_close0", + ][::std::mem::size_of::() - 1usize]; + [ + "Align of template specialization: B_open0_A_close0", + ][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/constify-all-enums.rs b/bindgen-tests/tests/expectations/tests/constify-all-enums.rs new file mode 100644 index 0000000000..7913454b56 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/constify-all-enums.rs @@ -0,0 +1,27 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const foo_THIS: foo = 0; +pub const foo_SHOULD_BE: foo = 1; +pub const foo_A_CONSTANT: foo = 2; +pub type foo = ::std::os::raw::c_uint; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bar { + pub this_should_work: foo, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of bar"][::std::mem::size_of::() - 4usize]; + ["Alignment of bar"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: bar::this_should_work", + ][::std::mem::offset_of!(bar, this_should_work) - 0usize]; +}; +impl Default for bar { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/constify-enum.rs b/bindgen-tests/tests/expectations/tests/constify-enum.rs new file mode 100644 index 0000000000..67d2749c51 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/constify-enum.rs @@ -0,0 +1,15 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const nsCSSPropertyID_eCSSProperty_COUNT_unexistingVariantValue: nsCSSPropertyID = nsCSSPropertyID::eCSSProperty_COUNT_unexistingVariantValue; +impl nsCSSPropertyID { + pub const eCSSProperty_COUNT: nsCSSPropertyID = nsCSSPropertyID::eCSSPropertyAlias_aa; +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum nsCSSPropertyID { + eCSSProperty_a = 0, + eCSSProperty_b = 1, + eCSSPropertyAlias_aa = 2, + eCSSPropertyAlias_bb = 3, + ///<
+ eCSSProperty_COUNT_unexistingVariantValue = 4, +} diff --git a/bindgen-tests/tests/expectations/tests/constify-module-enums-basic.rs b/bindgen-tests/tests/expectations/tests/constify-module-enums-basic.rs new file mode 100644 index 0000000000..aad696d074 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/constify-module-enums-basic.rs @@ -0,0 +1,47 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod foo { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_uint; + pub const THIS: Type = 0; + pub const SHOULD_BE: Type = 1; + pub const A_CONSTANT: Type = 2; +} +pub use self::foo::Type as foo_alias1; +pub use self::foo_alias1 as foo_alias2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bar { + pub this_should_work: foo::Type, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of bar"][::std::mem::size_of::() - 4usize]; + ["Alignment of bar"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: bar::this_should_work", + ][::std::mem::offset_of!(bar, this_should_work) - 0usize]; +}; +impl Default for bar { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +unsafe extern "C" { + pub fn func1( + arg1: foo::Type, + arg2: *mut foo::Type, + arg3: *mut *mut foo::Type, + ) -> *mut foo::Type; +} +unsafe extern "C" { + pub fn func2( + arg1: foo_alias1, + arg2: *mut foo_alias1, + arg3: *mut *mut foo_alias1, + ) -> *mut foo_alias1; +} diff --git a/bindgen-tests/tests/expectations/tests/constify-module-enums-namespace.rs b/bindgen-tests/tests/expectations/tests/constify-module-enums-namespace.rs new file mode 100644 index 0000000000..cdf6e7ebb4 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/constify-module-enums-namespace.rs @@ -0,0 +1,48 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod ns1 { + #[allow(unused_imports)] + use self::super::super::root; + pub mod ns2 { + #[allow(unused_imports)] + use self::super::super::super::root; + pub mod foo { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_uint; + pub const THIS: Type = 0; + pub const SHOULD_BE: Type = 1; + pub const A_CONSTANT: Type = 2; + } + } + pub mod ns3 { + #[allow(unused_imports)] + use self::super::super::super::root; + #[repr(C)] + #[derive(Debug, Copy, Clone)] + pub struct bar { + pub this_should_work: root::ns1::ns2::foo::Type, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of bar"][::std::mem::size_of::() - 4usize]; + ["Alignment of bar"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: bar::this_should_work", + ][::std::mem::offset_of!(bar, this_should_work) - 0usize]; + }; + impl Default for bar { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } + } + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/constify-module-enums-shadow-name.rs b/bindgen-tests/tests/expectations/tests/constify-module-enums-shadow-name.rs new file mode 100644 index 0000000000..987f4463a2 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/constify-module-enums-shadow-name.rs @@ -0,0 +1,30 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod foo { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_uint; + pub const Type: Type = 0; + pub const Type_: Type = 1; + pub const Type1: Type = 2; + pub const Type__: Type = 3; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bar { + pub member: foo::Type, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of bar"][::std::mem::size_of::() - 4usize]; + ["Alignment of bar"][::std::mem::align_of::() - 4usize]; + ["Offset of field: bar::member"][::std::mem::offset_of!(bar, member) - 0usize]; +}; +impl Default for bar { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/constify-module-enums-simple-alias.rs b/bindgen-tests/tests/expectations/tests/constify-module-enums-simple-alias.rs new file mode 100644 index 0000000000..5f7b9ede4a --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/constify-module-enums-simple-alias.rs @@ -0,0 +1,46 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod Foo { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_int; + pub const Variant1: Type = 0; + pub const Variant2: Type = 1; + pub const Variant3: Type = 2; +} +pub use self::Foo::Type as Foo_alias1; +pub use self::Foo_alias1 as Foo_alias2; +pub use self::Foo_alias2 as Foo_alias3; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Bar { + pub baz1: Foo::Type, + pub baz2: Foo_alias1, + pub baz3: Foo_alias2, + pub baz4: Foo_alias3, + pub baz_ptr1: *mut Foo::Type, + pub baz_ptr2: *mut Foo_alias1, + pub baz_ptr3: *mut Foo_alias2, + pub baz_ptr4: *mut Foo_alias3, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 48usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Bar::baz1"][::std::mem::offset_of!(Bar, baz1) - 0usize]; + ["Offset of field: Bar::baz2"][::std::mem::offset_of!(Bar, baz2) - 4usize]; + ["Offset of field: Bar::baz3"][::std::mem::offset_of!(Bar, baz3) - 8usize]; + ["Offset of field: Bar::baz4"][::std::mem::offset_of!(Bar, baz4) - 12usize]; + ["Offset of field: Bar::baz_ptr1"][::std::mem::offset_of!(Bar, baz_ptr1) - 16usize]; + ["Offset of field: Bar::baz_ptr2"][::std::mem::offset_of!(Bar, baz_ptr2) - 24usize]; + ["Offset of field: Bar::baz_ptr3"][::std::mem::offset_of!(Bar, baz_ptr3) - 32usize]; + ["Offset of field: Bar::baz_ptr4"][::std::mem::offset_of!(Bar, baz_ptr4) - 40usize]; +}; +impl Default for Bar { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/constify-module-enums-simple-nonamespace.rs b/bindgen-tests/tests/expectations/tests/constify-module-enums-simple-nonamespace.rs new file mode 100644 index 0000000000..dc59f5fc1d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/constify-module-enums-simple-nonamespace.rs @@ -0,0 +1,30 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod one_Foo { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_int; + pub const Variant1: Type = 0; + pub const Variant2: Type = 1; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Bar { + pub baz1: one_Foo::Type, + pub baz2: *mut one_Foo::Type, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 16usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Bar::baz1"][::std::mem::offset_of!(Bar, baz1) - 0usize]; + ["Offset of field: Bar::baz2"][::std::mem::offset_of!(Bar, baz2) - 8usize]; +}; +impl Default for Bar { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/constify-module-enums-types.rs b/bindgen-tests/tests/expectations/tests/constify-module-enums-types.rs new file mode 100644 index 0000000000..a4a69fd72d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/constify-module-enums-types.rs @@ -0,0 +1,173 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type Uint = ::std::os::raw::c_uint; +pub mod ExplicitTypeAlias { + #[allow(unused_imports)] + use super::*; + pub type Type = Uint; + pub const SOME_CONSTANT: Type = 0; + pub const SOME_OTHER_CONSTANT: Type = 1; +} +pub mod foo { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_uint; + pub const THIS: Type = 0; + pub const SHOULD_BE: Type = 1; + pub const A_CONSTANT: Type = 2; + pub const ALSO_THIS: Type = 42; + pub const AND_ALSO_THIS: Type = 42; +} +pub mod anon_enum { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_uint; + pub const Variant1: Type = 0; + pub const Variant2: Type = 1; + pub const Variant3: Type = 2; +} +pub mod ns1_foo { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_uint; + pub const THIS: Type = 0; + pub const SHOULD_BE: Type = 1; + pub const A_CONSTANT: Type = 2; + pub const ALSO_THIS: Type = 42; +} +pub mod ns2_Foo { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_int; + pub const Variant1: Type = 0; + pub const Variant2: Type = 1; +} +pub use self::foo::Type as foo_alias1; +pub use self::foo_alias1 as foo_alias2; +pub use self::foo_alias2 as foo_alias3; +pub use self::anon_enum::Type as anon_enum_alias1; +pub use self::anon_enum_alias1 as anon_enum_alias2; +pub use self::anon_enum_alias2 as anon_enum_alias3; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bar { + pub member1: foo::Type, + pub member2: foo_alias1, + pub member3: foo_alias2, + pub member4: foo_alias3, + pub member5: ns1_foo::Type, + pub member6: *mut ns2_Foo::Type, + pub member7: anon_enum::Type, + pub member8: anon_enum_alias1, + pub member9: anon_enum_alias2, + pub member10: anon_enum_alias3, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of bar"][::std::mem::size_of::() - 48usize]; + ["Alignment of bar"][::std::mem::align_of::() - 8usize]; + ["Offset of field: bar::member1"][::std::mem::offset_of!(bar, member1) - 0usize]; + ["Offset of field: bar::member2"][::std::mem::offset_of!(bar, member2) - 4usize]; + ["Offset of field: bar::member3"][::std::mem::offset_of!(bar, member3) - 8usize]; + ["Offset of field: bar::member4"][::std::mem::offset_of!(bar, member4) - 12usize]; + ["Offset of field: bar::member5"][::std::mem::offset_of!(bar, member5) - 16usize]; + ["Offset of field: bar::member6"][::std::mem::offset_of!(bar, member6) - 24usize]; + ["Offset of field: bar::member7"][::std::mem::offset_of!(bar, member7) - 32usize]; + ["Offset of field: bar::member8"][::std::mem::offset_of!(bar, member8) - 36usize]; + ["Offset of field: bar::member9"][::std::mem::offset_of!(bar, member9) - 40usize]; + ["Offset of field: bar::member10"][::std::mem::offset_of!(bar, member10) - 44usize]; +}; +impl Default for bar { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Baz { + pub member1: ns2_Foo::Type, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Baz"][::std::mem::size_of::() - 4usize]; + ["Alignment of Baz"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Baz::member1"][::std::mem::offset_of!(Baz, member1) - 0usize]; +}; +impl Default for Baz { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub mod one_Foo { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_int; + pub const Variant1: Type = 0; + pub const Variant2: Type = 1; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Bar { + pub baz: *mut one_Foo::Type, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 8usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Bar::baz"][::std::mem::offset_of!(Bar, baz) - 0usize]; +}; +impl Default for Bar { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +unsafe extern "C" { + #[link_name = "\u{1}_Z5func13fooPS_PS0_"] + pub fn func1( + arg1: foo::Type, + arg2: *mut foo::Type, + arg3: *mut *mut foo::Type, + ) -> *mut foo::Type; +} +unsafe extern "C" { + #[link_name = "\u{1}_Z5func23fooPS_PS0_"] + pub fn func2( + arg1: foo_alias1, + arg2: *mut foo_alias1, + arg3: *mut *mut foo_alias1, + ) -> *mut foo_alias1; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Thing { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub thing: T, +} +impl Default for Thing { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +unsafe extern "C" { + #[link_name = "\u{1}_Z5func35ThingI3fooE"] + pub fn func3(arg1: Thing) -> foo::Type; +} +unsafe extern "C" { + #[link_name = "\u{1}_Z5func45ThingIS_I3fooEE"] + pub fn func4(arg1: Thing>) -> foo::Type; +} diff --git a/bindgen-tests/tests/expectations/tests/constructor-tp.rs b/bindgen-tests/tests/expectations/tests/constructor-tp.rs new file mode 100644 index 0000000000..2585311d29 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/constructor-tp.rs @@ -0,0 +1,28 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Bar { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 1usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN3BarC1Ev"] + pub fn Bar_Bar(this: *mut Bar); +} +impl Bar { + #[inline] + pub unsafe fn new() -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + Bar_Bar(__bindgen_tmp.as_mut_ptr()); + __bindgen_tmp.assume_init() + } +} diff --git a/bindgen-tests/tests/expectations/tests/constructors.rs b/bindgen-tests/tests/expectations/tests/constructors.rs new file mode 100644 index 0000000000..45c29e61e5 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/constructors.rs @@ -0,0 +1,60 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct TestOverload { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of TestOverload"][::std::mem::size_of::() - 1usize]; + ["Alignment of TestOverload"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN12TestOverloadC1Ei"] + pub fn TestOverload_TestOverload( + this: *mut TestOverload, + arg1: ::std::os::raw::c_int, + ); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN12TestOverloadC1Ed"] + pub fn TestOverload_TestOverload1(this: *mut TestOverload, arg1: f64); +} +impl TestOverload { + #[inline] + pub unsafe fn new(arg1: ::std::os::raw::c_int) -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + TestOverload_TestOverload(__bindgen_tmp.as_mut_ptr(), arg1); + __bindgen_tmp.assume_init() + } + #[inline] + pub unsafe fn new1(arg1: f64) -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + TestOverload_TestOverload1(__bindgen_tmp.as_mut_ptr(), arg1); + __bindgen_tmp.assume_init() + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct TestPublicNoArgs { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of TestPublicNoArgs"][::std::mem::size_of::() - 1usize]; + [ + "Alignment of TestPublicNoArgs", + ][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN16TestPublicNoArgsC1Ev"] + pub fn TestPublicNoArgs_TestPublicNoArgs(this: *mut TestPublicNoArgs); +} +impl TestPublicNoArgs { + #[inline] + pub unsafe fn new() -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + TestPublicNoArgs_TestPublicNoArgs(__bindgen_tmp.as_mut_ptr()); + __bindgen_tmp.assume_init() + } +} diff --git a/bindgen-tests/tests/expectations/tests/constructors_1_33.rs b/bindgen-tests/tests/expectations/tests/constructors_1_33.rs new file mode 100644 index 0000000000..5dbda00007 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/constructors_1_33.rs @@ -0,0 +1,62 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct TestOverload { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of TestOverload"][::std::mem::size_of::() - 1usize]; + ["Alignment of TestOverload"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + /// Calling this should use `mem::unintialized()` and not `MaybeUninit()` as only rust 1.36 includes that. + #[link_name = "\u{1}_ZN12TestOverloadC1Ei"] + pub fn TestOverload_TestOverload( + this: *mut TestOverload, + arg1: ::std::os::raw::c_int, + ); +} +unsafe extern "C" { + /// Calling this should use `mem::unintialized()` and not `MaybeUninit()` as only rust 1.36 includes that. + #[link_name = "\u{1}_ZN12TestOverloadC1Ed"] + pub fn TestOverload_TestOverload1(this: *mut TestOverload, arg1: f64); +} +impl TestOverload { + #[inline] + pub unsafe fn new(arg1: ::std::os::raw::c_int) -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + TestOverload_TestOverload(__bindgen_tmp.as_mut_ptr(), arg1); + __bindgen_tmp.assume_init() + } + #[inline] + pub unsafe fn new1(arg1: f64) -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + TestOverload_TestOverload1(__bindgen_tmp.as_mut_ptr(), arg1); + __bindgen_tmp.assume_init() + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct TestPublicNoArgs { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of TestPublicNoArgs"][::std::mem::size_of::() - 1usize]; + [ + "Alignment of TestPublicNoArgs", + ][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN16TestPublicNoArgsC1Ev"] + pub fn TestPublicNoArgs_TestPublicNoArgs(this: *mut TestPublicNoArgs); +} +impl TestPublicNoArgs { + #[inline] + pub unsafe fn new() -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + TestPublicNoArgs_TestPublicNoArgs(__bindgen_tmp.as_mut_ptr()); + __bindgen_tmp.assume_init() + } +} diff --git a/bindgen-tests/tests/expectations/tests/contains-vs-inherits-zero-sized.rs b/bindgen-tests/tests/expectations/tests/contains-vs-inherits-zero-sized.rs new file mode 100644 index 0000000000..3362280843 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/contains-vs-inherits-zero-sized.rs @@ -0,0 +1,42 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +/// This should get an `_address` byte. +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Empty { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Empty"][::std::mem::size_of::() - 1usize]; + ["Alignment of Empty"][::std::mem::align_of::() - 1usize]; +}; +/** This should not get an `_address` byte, so `sizeof(Inherits)` should be + `1`.*/ +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Inherits { + pub b: bool, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Inherits"][::std::mem::size_of::() - 1usize]; + ["Alignment of Inherits"][::std::mem::align_of::() - 1usize]; + ["Offset of field: Inherits::b"][::std::mem::offset_of!(Inherits, b) - 0usize]; +}; +/** This should not get an `_address` byte, but contains `Empty` which *does* get + one, so `sizeof(Contains)` should be `1 + 1`.*/ +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Contains { + pub empty: Empty, + pub b: bool, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Contains"][::std::mem::size_of::() - 2usize]; + ["Alignment of Contains"][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: Contains::empty", + ][::std::mem::offset_of!(Contains, empty) - 0usize]; + ["Offset of field: Contains::b"][::std::mem::offset_of!(Contains, b) - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/convert-cpp-comment-to-rust.rs b/bindgen-tests/tests/expectations/tests/convert-cpp-comment-to-rust.rs new file mode 100644 index 0000000000..96f9e6fd2a --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/convert-cpp-comment-to-rust.rs @@ -0,0 +1,22 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type mbedtls_mpi_uint = ::std::os::raw::c_uint; +/// \brief MPI structure +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct mbedtls_mpi { + ///< integer sign + pub s: ::std::os::raw::c_int, + ///< total # of limbs + pub n: ::std::os::raw::c_ulong, + ///< pointer to limbs + pub p: *mut mbedtls_mpi_uint, +} +impl Default for mbedtls_mpi { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/convert-floats.rs b/bindgen-tests/tests/expectations/tests/convert-floats.rs new file mode 100644 index 0000000000..9ca939f7c5 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/convert-floats.rs @@ -0,0 +1,41 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[derive(PartialEq, Copy, Clone, Hash, Debug, Default)] +#[repr(C)] +pub struct __BindgenComplex { + pub re: T, + pub im: T, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct foo { + pub bar: ::std::os::raw::c_float, + pub baz: ::std::os::raw::c_float, + pub bazz: ::std::os::raw::c_double, + pub bazzz: *mut u128, + pub complexFloat: __BindgenComplex<::std::os::raw::c_float>, + pub complexDouble: __BindgenComplex<::std::os::raw::c_double>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 48usize]; + ["Alignment of foo"][::std::mem::align_of::() - 8usize]; + ["Offset of field: foo::bar"][::std::mem::offset_of!(foo, bar) - 0usize]; + ["Offset of field: foo::baz"][::std::mem::offset_of!(foo, baz) - 4usize]; + ["Offset of field: foo::bazz"][::std::mem::offset_of!(foo, bazz) - 8usize]; + ["Offset of field: foo::bazzz"][::std::mem::offset_of!(foo, bazzz) - 16usize]; + [ + "Offset of field: foo::complexFloat", + ][::std::mem::offset_of!(foo, complexFloat) - 24usize]; + [ + "Offset of field: foo::complexDouble", + ][::std::mem::offset_of!(foo, complexDouble) - 32usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/core_ffi_c.rs b/bindgen-tests/tests/expectations/tests/core_ffi_c.rs new file mode 100644 index 0000000000..42c9272034 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/core_ffi_c.rs @@ -0,0 +1,14 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type c_char = ::core::ffi::c_char; +pub type c_double = ::core::ffi::c_double; +pub type c_float = ::core::ffi::c_float; +pub type c_int = ::core::ffi::c_int; +pub type c_long = ::core::ffi::c_long; +pub type c_longlong = ::core::ffi::c_longlong; +pub type c_schar = ::core::ffi::c_schar; +pub type c_short = ::core::ffi::c_short; +pub type c_uchar = ::core::ffi::c_uchar; +pub type c_uint = ::core::ffi::c_uint; +pub type c_ulong = ::core::ffi::c_ulong; +pub type c_ulonglong = ::core::ffi::c_ulonglong; +pub type c_ushort = ::core::ffi::c_ushort; diff --git a/bindgen-tests/tests/expectations/tests/cpp-empty-layout.rs b/bindgen-tests/tests/expectations/tests/cpp-empty-layout.rs new file mode 100644 index 0000000000..551dff82cf --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/cpp-empty-layout.rs @@ -0,0 +1,11 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/crtp.rs b/bindgen-tests/tests/expectations/tests/crtp.rs new file mode 100644 index 0000000000..68397041b7 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/crtp.rs @@ -0,0 +1,53 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Base { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Derived { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Derived"][::std::mem::size_of::() - 1usize]; + ["Alignment of Derived"][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Default)] +pub struct BaseWithDestructor { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Default)] +pub struct DerivedFromBaseWithDestructor { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of DerivedFromBaseWithDestructor", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of DerivedFromBaseWithDestructor", + ][::std::mem::align_of::() - 1usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: Base_open0_Derived_close0", + ][::std::mem::size_of::() - 1usize]; + [ + "Align of template specialization: Base_open0_Derived_close0", + ][::std::mem::align_of::() - 1usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: BaseWithDestructor_open0_DerivedFromBaseWithDestructor_close0", + ][::std::mem::size_of::() - 1usize]; + [ + "Align of template specialization: BaseWithDestructor_open0_DerivedFromBaseWithDestructor_close0", + ][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/ctypes-prefix-path.rs b/bindgen-tests/tests/expectations/tests/ctypes-prefix-path.rs new file mode 100644 index 0000000000..5f947f9cea --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/ctypes-prefix-path.rs @@ -0,0 +1,32 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![no_std] +mod libc { + pub mod foo { + pub type c_int = i32; + pub enum c_void {} + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct foo { + pub a: libc::foo::c_int, + pub b: libc::foo::c_int, + pub bar: *mut libc::foo::c_void, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::core::mem::size_of::() - 16usize]; + ["Alignment of foo"][::core::mem::align_of::() - 8usize]; + ["Offset of field: foo::a"][::core::mem::offset_of!(foo, a) - 0usize]; + ["Offset of field: foo::b"][::core::mem::offset_of!(foo, b) - 4usize]; + ["Offset of field: foo::bar"][::core::mem::offset_of!(foo, bar) - 8usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/dash_language.rs b/bindgen-tests/tests/expectations/tests/dash_language.rs new file mode 100644 index 0000000000..f405a35604 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/dash_language.rs @@ -0,0 +1,6 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub bar: ::std::os::raw::c_int, +} diff --git a/bindgen-tests/tests/expectations/tests/decl_extern_int_twice.rs b/bindgen-tests/tests/expectations/tests/decl_extern_int_twice.rs new file mode 100644 index 0000000000..122d41a12d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/decl_extern_int_twice.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub static mut foo: ::std::os::raw::c_int; +} diff --git a/bindgen-tests/tests/expectations/tests/decl_ptr_to_array.rs b/bindgen-tests/tests/expectations/tests/decl_ptr_to_array.rs new file mode 100644 index 0000000000..a559d33b4a --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/decl_ptr_to_array.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub static mut foo: *mut [::std::os::raw::c_int; 1usize]; +} diff --git a/bindgen-tests/tests/expectations/tests/default-enum-style-constified-module.rs b/bindgen-tests/tests/expectations/tests/default-enum-style-constified-module.rs new file mode 100644 index 0000000000..2a75aa8d86 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/default-enum-style-constified-module.rs @@ -0,0 +1,12 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod Foo { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_uint; + pub const bar: Type = 0; + pub const baz: Type = 1; + pub const blap: Type = 2; +} +unsafe extern "C" { + pub fn func(x: Foo::Type); +} diff --git a/bindgen-tests/tests/expectations/tests/default-macro-constant-type-signed.rs b/bindgen-tests/tests/expectations/tests/default-macro-constant-type-signed.rs new file mode 100644 index 0000000000..7fca57b6b9 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/default-macro-constant-type-signed.rs @@ -0,0 +1,48 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const N0: i32 = 0; +pub const N1: i32 = 1; +pub const N2: i32 = 2; +pub const N_1: i32 = -1; +pub const N_2: i32 = -2; +pub const MAX_U16: i32 = 65535; +pub const MAX_I16: i32 = 32767; +pub const MAX_I16_Plus1: i32 = 32768; +pub const MAX_U16_Plus1: i32 = 65536; +pub const MAX_I16_Minus1: i32 = 32766; +pub const MAX_U16_Minus1: i32 = 65534; +pub const MIN_U16: i32 = 0; +pub const MIN_I16: i32 = -32768; +pub const MIN_U16_Plus1: i32 = 1; +pub const MIN_I16_Plus1: i32 = -32767; +pub const MIN_U16_Minus1: i32 = -1; +pub const MIN_I16_Minus1: i32 = -32769; +pub const MAX_U32: i64 = 4294967295; +pub const MAX_I32: i32 = 2147483647; +pub const MAX_I32_Plus1: i64 = 2147483648; +pub const MAX_U32_Plus1: i64 = 4294967296; +pub const MAX_I32_Minus1: i32 = 2147483646; +pub const MAX_U32_Minus1: i64 = 4294967294; +pub const MIN_U32: i32 = 0; +pub const MIN_I32: i32 = -2147483648; +pub const MIN_U32_Plus1: i32 = 1; +pub const MIN_I32_Plus1: i32 = -2147483647; +pub const MIN_U32_Minus1: i32 = -1; +pub const MIN_I32_Minus1: i64 = -2147483649; +pub const LONG12: i64 = 123456789012; +pub const LONG_12: i64 = -123456789012; +unsafe extern "C" { + pub fn foo( + arg1: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_uint, + arg4: ::std::os::raw::c_char, + arg5: ::std::os::raw::c_uchar, + arg6: ::std::os::raw::c_schar, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bar( + arg1: ::std::os::raw::c_long, + arg2: ::std::os::raw::c_longlong, + ) -> ::std::os::raw::c_long; +} diff --git a/bindgen-tests/tests/expectations/tests/default-macro-constant-type-unsigned.rs b/bindgen-tests/tests/expectations/tests/default-macro-constant-type-unsigned.rs new file mode 100644 index 0000000000..d34d050a1a --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/default-macro-constant-type-unsigned.rs @@ -0,0 +1,48 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const N0: u32 = 0; +pub const N1: u32 = 1; +pub const N2: u32 = 2; +pub const N_1: i32 = -1; +pub const N_2: i32 = -2; +pub const MAX_U16: u32 = 65535; +pub const MAX_I16: u32 = 32767; +pub const MAX_I16_Plus1: u32 = 32768; +pub const MAX_U16_Plus1: u32 = 65536; +pub const MAX_I16_Minus1: u32 = 32766; +pub const MAX_U16_Minus1: u32 = 65534; +pub const MIN_U16: u32 = 0; +pub const MIN_I16: i32 = -32768; +pub const MIN_U16_Plus1: u32 = 1; +pub const MIN_I16_Plus1: i32 = -32767; +pub const MIN_U16_Minus1: i32 = -1; +pub const MIN_I16_Minus1: i32 = -32769; +pub const MAX_U32: u32 = 4294967295; +pub const MAX_I32: u32 = 2147483647; +pub const MAX_I32_Plus1: u32 = 2147483648; +pub const MAX_U32_Plus1: u64 = 4294967296; +pub const MAX_I32_Minus1: u32 = 2147483646; +pub const MAX_U32_Minus1: u32 = 4294967294; +pub const MIN_U32: u32 = 0; +pub const MIN_I32: i32 = -2147483648; +pub const MIN_U32_Plus1: u32 = 1; +pub const MIN_I32_Plus1: i32 = -2147483647; +pub const MIN_U32_Minus1: i32 = -1; +pub const MIN_I32_Minus1: i64 = -2147483649; +pub const LONG12: u64 = 123456789012; +pub const LONG_12: i64 = -123456789012; +unsafe extern "C" { + pub fn foo( + arg1: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_uint, + arg4: ::std::os::raw::c_char, + arg5: ::std::os::raw::c_uchar, + arg6: ::std::os::raw::c_schar, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bar( + arg1: ::std::os::raw::c_long, + arg2: ::std::os::raw::c_longlong, + ) -> ::std::os::raw::c_long; +} diff --git a/bindgen-tests/tests/expectations/tests/default-macro-constant-type.rs b/bindgen-tests/tests/expectations/tests/default-macro-constant-type.rs new file mode 100644 index 0000000000..d34d050a1a --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/default-macro-constant-type.rs @@ -0,0 +1,48 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const N0: u32 = 0; +pub const N1: u32 = 1; +pub const N2: u32 = 2; +pub const N_1: i32 = -1; +pub const N_2: i32 = -2; +pub const MAX_U16: u32 = 65535; +pub const MAX_I16: u32 = 32767; +pub const MAX_I16_Plus1: u32 = 32768; +pub const MAX_U16_Plus1: u32 = 65536; +pub const MAX_I16_Minus1: u32 = 32766; +pub const MAX_U16_Minus1: u32 = 65534; +pub const MIN_U16: u32 = 0; +pub const MIN_I16: i32 = -32768; +pub const MIN_U16_Plus1: u32 = 1; +pub const MIN_I16_Plus1: i32 = -32767; +pub const MIN_U16_Minus1: i32 = -1; +pub const MIN_I16_Minus1: i32 = -32769; +pub const MAX_U32: u32 = 4294967295; +pub const MAX_I32: u32 = 2147483647; +pub const MAX_I32_Plus1: u32 = 2147483648; +pub const MAX_U32_Plus1: u64 = 4294967296; +pub const MAX_I32_Minus1: u32 = 2147483646; +pub const MAX_U32_Minus1: u32 = 4294967294; +pub const MIN_U32: u32 = 0; +pub const MIN_I32: i32 = -2147483648; +pub const MIN_U32_Plus1: u32 = 1; +pub const MIN_I32_Plus1: i32 = -2147483647; +pub const MIN_U32_Minus1: i32 = -1; +pub const MIN_I32_Minus1: i64 = -2147483649; +pub const LONG12: u64 = 123456789012; +pub const LONG_12: i64 = -123456789012; +unsafe extern "C" { + pub fn foo( + arg1: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_uint, + arg4: ::std::os::raw::c_char, + arg5: ::std::os::raw::c_uchar, + arg6: ::std::os::raw::c_schar, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bar( + arg1: ::std::os::raw::c_long, + arg2: ::std::os::raw::c_longlong, + ) -> ::std::os::raw::c_long; +} diff --git a/bindgen-tests/tests/expectations/tests/default-template-parameter.rs b/bindgen-tests/tests/expectations/tests/default-template-parameter.rs new file mode 100644 index 0000000000..67f8a486de --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/default-template-parameter.rs @@ -0,0 +1,31 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Foo { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub t: T, + pub u: U, +} +impl Default for Foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: Foo_open0_bool__int_close0", + ][::std::mem::size_of::>() - 8usize]; + [ + "Align of template specialization: Foo_open0_bool__int_close0", + ][::std::mem::align_of::>() - 4usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZL3bar"] + pub static mut bar: Foo; +} diff --git a/bindgen-tests/tests/expectations/tests/default_visibility_crate.rs b/bindgen-tests/tests/expectations/tests/default_visibility_crate.rs new file mode 100644 index 0000000000..aeefb2e0f9 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/default_visibility_crate.rs @@ -0,0 +1,301 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Point { + pub(crate) x: ::std::os::raw::c_int, + pub(crate) y: ::std::os::raw::c_int, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Color { + pub(crate) _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, +} +impl Color { + #[inline] + pub(crate) fn r(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub(crate) fn set_r(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub(crate) unsafe fn r_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8, + ) + } + } + #[inline] + pub(crate) unsafe fn set_r_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub(crate) fn g(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } + } + #[inline] + pub(crate) fn set_g(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub(crate) unsafe fn g_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) as u8, + ) + } + } + #[inline] + pub(crate) unsafe fn set_g_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub(crate) fn b(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) } + } + #[inline] + pub(crate) fn set_b(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub(crate) unsafe fn b_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8) as u8, + ) + } + } + #[inline] + pub(crate) unsafe fn set_b_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub(crate) fn new_bitfield_1( + r: ::std::os::raw::c_char, + g: ::std::os::raw::c_char, + b: ::std::os::raw::c_char, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let r: u8 = unsafe { ::std::mem::transmute(r) }; + r as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 1u8, + { + let g: u8 = unsafe { ::std::mem::transmute(g) }; + g as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 2usize, + 1u8, + { + let b: u8 = unsafe { ::std::mem::transmute(b) }; + b as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/default_visibility_private.rs b/bindgen-tests/tests/expectations/tests/default_visibility_private.rs new file mode 100644 index 0000000000..dceed75e36 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/default_visibility_private.rs @@ -0,0 +1,301 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Point { + x: ::std::os::raw::c_int, + y: ::std::os::raw::c_int, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Color { + _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, +} +impl Color { + #[inline] + fn r(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + fn set_r(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + unsafe fn r_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8, + ) + } + } + #[inline] + unsafe fn set_r_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + fn g(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } + } + #[inline] + fn set_g(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + unsafe fn g_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) as u8, + ) + } + } + #[inline] + unsafe fn set_g_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + fn b(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) } + } + #[inline] + fn set_b(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + unsafe fn b_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8) as u8, + ) + } + } + #[inline] + unsafe fn set_b_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + fn new_bitfield_1( + r: ::std::os::raw::c_char, + g: ::std::os::raw::c_char, + b: ::std::os::raw::c_char, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let r: u8 = unsafe { ::std::mem::transmute(r) }; + r as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 1u8, + { + let g: u8 = unsafe { ::std::mem::transmute(g) }; + g as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 2usize, + 1u8, + { + let b: u8 = unsafe { ::std::mem::transmute(b) }; + b as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/default_visibility_private_respects_cxx_access_spec.rs b/bindgen-tests/tests/expectations/tests/default_visibility_private_respects_cxx_access_spec.rs new file mode 100644 index 0000000000..f43be84bb0 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/default_visibility_private_respects_cxx_access_spec.rs @@ -0,0 +1,301 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Point { + pub x: ::std::os::raw::c_int, + pub y: ::std::os::raw::c_int, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Color { + _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, +} +impl Color { + #[inline] + pub fn r(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_r(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn r_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_r_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn g(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } + } + #[inline] + pub fn set_g(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn g_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_g_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn b(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) } + } + #[inline] + pub fn set_b(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn b_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_b_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + fn new_bitfield_1( + r: ::std::os::raw::c_char, + g: ::std::os::raw::c_char, + b: ::std::os::raw::c_char, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let r: u8 = unsafe { ::std::mem::transmute(r) }; + r as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 1u8, + { + let g: u8 = unsafe { ::std::mem::transmute(g) }; + g as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 2usize, + 1u8, + { + let b: u8 = unsafe { ::std::mem::transmute(b) }; + b as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/deleted-function.rs b/bindgen-tests/tests/expectations/tests/deleted-function.rs new file mode 100644 index 0000000000..fc8588121f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/deleted-function.rs @@ -0,0 +1,61 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct A { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A"][::std::mem::size_of::() - 1usize]; + ["Alignment of A"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN1A17inline_definitionEv"] + pub fn A_inline_definition(this: *mut A); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN1A22out_of_line_definitionEv"] + pub fn A_out_of_line_definition(this: *mut A); +} +impl A { + #[inline] + pub unsafe fn inline_definition(&mut self) { + A_inline_definition(self) + } + #[inline] + pub unsafe fn out_of_line_definition(&mut self) { + A_out_of_line_definition(self) + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct B { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of B"][::std::mem::size_of::() - 1usize]; + ["Alignment of B"][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct C { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C"][::std::mem::size_of::() - 1usize]; + ["Alignment of C"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN1CC1ERS_"] + pub fn C_C(this: *mut C, arg1: *mut C); +} +impl C { + #[inline] + pub unsafe fn new(arg1: *mut C) -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + C_C(__bindgen_tmp.as_mut_ptr(), arg1); + __bindgen_tmp.assume_init() + } +} diff --git a/bindgen-tests/tests/expectations/tests/derive-bitfield-method-same-name.rs b/bindgen-tests/tests/expectations/tests/derive-bitfield-method-same-name.rs new file mode 100644 index 0000000000..7fa8bc41ab --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-bitfield-method-same-name.rs @@ -0,0 +1,256 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +/** Because this struct have array larger than 32 items + and --with-derive-partialeq --impl-partialeq --impl-debug is provided, + this struct should manually implement `Debug` and `PartialEq`.*/ +#[repr(C)] +#[derive(Debug, Copy, Clone, PartialEq)] +pub struct Foo { + pub large: [::std::os::raw::c_int; 33usize], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, + pub __bindgen_padding_0: u16, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 136usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Foo::large"][::std::mem::offset_of!(Foo, large) - 0usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN3Foo4typeEv"] + pub fn Foo_type(this: *mut Foo) -> ::std::os::raw::c_char; +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN3Foo9set_type_Ec"] + pub fn Foo_set_type_(this: *mut Foo, c: ::std::os::raw::c_char); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN3Foo8set_typeEc"] + pub fn Foo_set_type(this: *mut Foo, c: ::std::os::raw::c_char); +} +impl Default for Foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Foo { + #[inline] + pub fn type__bindgen_bitfield(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u8) } + } + #[inline] + pub fn set_type__bindgen_bitfield(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn type__bindgen_bitfield_raw( + this: *const Self, + ) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 3u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_type__bindgen_bitfield_raw( + this: *mut Self, + val: ::std::os::raw::c_char, + ) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + type__bindgen_bitfield: ::std::os::raw::c_char, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 3u8, + { + let type__bindgen_bitfield: u8 = unsafe { + ::std::mem::transmute(type__bindgen_bitfield) + }; + type__bindgen_bitfield as u64 + }, + ); + __bindgen_bitfield_unit + } + #[inline] + pub unsafe fn type_(&mut self) -> ::std::os::raw::c_char { + Foo_type(self) + } + #[inline] + pub unsafe fn set_type_(&mut self, c: ::std::os::raw::c_char) { + Foo_set_type_(self, c) + } + #[inline] + pub unsafe fn set_type(&mut self, c: ::std::os::raw::c_char) { + Foo_set_type(self, c) + } +} diff --git a/bindgen-tests/tests/expectations/tests/derive-clone.rs b/bindgen-tests/tests/expectations/tests/derive-clone.rs new file mode 100644 index 0000000000..ccbdf5bd70 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-clone.rs @@ -0,0 +1,26 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +/// This struct should derive `Clone`. +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ShouldDeriveClone { + pub large: [::std::os::raw::c_int; 33usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ShouldDeriveClone"][::std::mem::size_of::() - 132usize]; + [ + "Alignment of ShouldDeriveClone", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: ShouldDeriveClone::large", + ][::std::mem::offset_of!(ShouldDeriveClone, large) - 0usize]; +}; +impl Default for ShouldDeriveClone { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/derive-custom-cli.rs b/bindgen-tests/tests/expectations/tests/derive-custom-cli.rs new file mode 100644 index 0000000000..59a3a76571 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-custom-cli.rs @@ -0,0 +1,44 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Clone, Default)] +pub struct foo_struct { + pub inner: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo_struct"][::std::mem::size_of::() - 4usize]; + ["Alignment of foo_struct"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: foo_struct::inner", + ][::std::mem::offset_of!(foo_struct, inner) - 0usize]; +}; +#[repr(u32)] +#[derive(Clone, Hash, PartialEq, Eq, Copy)] +pub enum foo_enum { + inner = 0, +} +#[repr(C)] +#[derive(Clone, Copy)] +pub union foo_union { + pub fst: ::std::mem::ManuallyDrop<::std::os::raw::c_int>, + pub snd: ::std::mem::ManuallyDrop, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo_union"][::std::mem::size_of::() - 4usize]; + ["Alignment of foo_union"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo_union::fst"][::std::mem::offset_of!(foo_union, fst) - 0usize]; + ["Offset of field: foo_union::snd"][::std::mem::offset_of!(foo_union, snd) - 0usize]; +}; +#[repr(C)] +pub struct non_matching { + pub inner: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of non_matching"][::std::mem::size_of::() - 4usize]; + ["Alignment of non_matching"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: non_matching::inner", + ][::std::mem::offset_of!(non_matching, inner) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/derive-custom.rs b/bindgen-tests/tests/expectations/tests/derive-custom.rs new file mode 100644 index 0000000000..9a69ebbb73 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-custom.rs @@ -0,0 +1,20 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +///
+#[repr(C)] +#[derive(Default, Debug)] +pub struct my_type { + pub a: ::std::os::raw::c_int, +} +/**
+
*/ +#[repr(C)] +#[derive(Default, Debug, Clone)] +pub struct my_type2 { + pub a: ::std::os::raw::c_uint, +} +///
+#[repr(C)] +#[derive(Default, Debug, Clone)] +pub struct my_type3 { + pub a: ::std::os::raw::c_ulong, +} diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-1-51.rs b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-1-51.rs new file mode 100644 index 0000000000..87cbb7346c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-1-51.rs @@ -0,0 +1,263 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct C { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub large_array: [::std::os::raw::c_int; 50usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C"][::std::mem::size_of::() - 204usize]; + ["Alignment of C"][::std::mem::align_of::() - 4usize]; + ["Offset of field: C::large_array"][::std::mem::offset_of!(C, large_array) - 4usize]; +}; +impl Default for C { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl C { + #[inline] + pub fn a(&self) -> bool { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_a(&mut self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn a_raw(this: *const Self) -> bool { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_a_raw(this: *mut Self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn b(&self) -> bool { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8) } + } + #[inline] + pub fn set_b(&mut self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 7u8, val as u64) + } + } + #[inline] + pub unsafe fn b_raw(this: *const Self) -> bool { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 7u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_b_raw(this: *mut Self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 7u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(a: bool, b: bool) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let a: u8 = unsafe { ::std::mem::transmute(a) }; + a as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 7u8, + { + let b: u8 = unsafe { ::std::mem::transmute(b) }; + b as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-core.rs b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-core.rs new file mode 100644 index 0000000000..937ad4ad0c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-core.rs @@ -0,0 +1,268 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +extern crate core; +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct C { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub large_array: [::core::ffi::c_int; 50usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C"][::core::mem::size_of::() - 204usize]; + ["Alignment of C"][::core::mem::align_of::() - 4usize]; + [ + "Offset of field: C::large_array", + ][::core::mem::offset_of!(C, large_array) - 4usize]; +}; +impl Default for C { + fn default() -> Self { + let mut s = ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl C { + #[inline] + pub fn a(&self) -> bool { + unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_a(&mut self, val: bool) { + unsafe { + let val: u8 = ::core::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn a_raw(this: *const Self) -> bool { + unsafe { + ::core::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::core::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_a_raw(this: *mut Self, val: bool) { + unsafe { + let val: u8 = ::core::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::core::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn b(&self) -> bool { + unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8) } + } + #[inline] + pub fn set_b(&mut self, val: bool) { + unsafe { + let val: u8 = ::core::mem::transmute(val); + self._bitfield_1.set(1usize, 7u8, val as u64) + } + } + #[inline] + pub unsafe fn b_raw(this: *const Self) -> bool { + unsafe { + ::core::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::core::ptr::addr_of!((*this)._bitfield_1), 1usize, 7u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_b_raw(this: *mut Self, val: bool) { + unsafe { + let val: u8 = ::core::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::core::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 7u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(a: bool, b: bool) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let a: u8 = unsafe { ::core::mem::transmute(a) }; + a as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 7u8, + { + let b: u8 = unsafe { ::core::mem::transmute(b) }; + b as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-bitfield.rs b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield.rs new file mode 100644 index 0000000000..87cbb7346c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield.rs @@ -0,0 +1,263 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct C { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub large_array: [::std::os::raw::c_int; 50usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C"][::std::mem::size_of::() - 204usize]; + ["Alignment of C"][::std::mem::align_of::() - 4usize]; + ["Offset of field: C::large_array"][::std::mem::offset_of!(C, large_array) - 4usize]; +}; +impl Default for C { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl C { + #[inline] + pub fn a(&self) -> bool { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_a(&mut self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn a_raw(this: *const Self) -> bool { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_a_raw(this: *mut Self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn b(&self) -> bool { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8) } + } + #[inline] + pub fn set_b(&mut self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 7u8, val as u64) + } + } + #[inline] + pub unsafe fn b_raw(this: *const Self) -> bool { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 7u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_b_raw(this: *mut Self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 7u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(a: bool, b: bool) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let a: u8 = unsafe { ::std::mem::transmute(a) }; + a as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 7u8, + { + let b: u8 = unsafe { ::std::mem::transmute(b) }; + b as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-function-pointer.rs b/bindgen-tests/tests/expectations/tests/derive-debug-function-pointer.rs new file mode 100644 index 0000000000..eaaa8ef9d4 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-debug-function-pointer.rs @@ -0,0 +1,28 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Nice { + pub pointer: Nice_Function, + pub large_array: [::std::os::raw::c_int; 34usize], +} +pub type Nice_Function = ::std::option::Option< + unsafe extern "C" fn(data: ::std::os::raw::c_int), +>; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Nice"][::std::mem::size_of::() - 144usize]; + ["Alignment of Nice"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Nice::pointer"][::std::mem::offset_of!(Nice, pointer) - 0usize]; + [ + "Offset of field: Nice::large_array", + ][::std::mem::offset_of!(Nice, large_array) - 8usize]; +}; +impl Default for Nice { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-generic.rs b/bindgen-tests/tests/expectations/tests/derive-debug-generic.rs new file mode 100644 index 0000000000..86e530463f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-debug-generic.rs @@ -0,0 +1,16 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug)] +pub struct Generic { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub t: [T; 40usize], +} +impl Default for Generic { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-mangle-name.rs b/bindgen-tests/tests/expectations/tests/derive-debug-mangle-name.rs new file mode 100644 index 0000000000..34b4a87d65 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-debug-mangle-name.rs @@ -0,0 +1,74 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct perf_event_attr { + pub type_: ::std::os::raw::c_uint, + pub a: f32, + pub __bindgen_anon_1: perf_event_attr__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union perf_event_attr__bindgen_ty_1 { + pub b: ::std::os::raw::c_int, + pub c: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of perf_event_attr__bindgen_ty_1", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of perf_event_attr__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: perf_event_attr__bindgen_ty_1::b", + ][::std::mem::offset_of!(perf_event_attr__bindgen_ty_1, b) - 0usize]; + [ + "Offset of field: perf_event_attr__bindgen_ty_1::c", + ][::std::mem::offset_of!(perf_event_attr__bindgen_ty_1, c) - 0usize]; +}; +impl Default for perf_event_attr__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl ::std::fmt::Debug for perf_event_attr__bindgen_ty_1 { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + write!(f, "perf_event_attr__bindgen_ty_1 {{ union }}") + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of perf_event_attr"][::std::mem::size_of::() - 12usize]; + ["Alignment of perf_event_attr"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: perf_event_attr::type_", + ][::std::mem::offset_of!(perf_event_attr, type_) - 0usize]; + [ + "Offset of field: perf_event_attr::a", + ][::std::mem::offset_of!(perf_event_attr, a) - 4usize]; +}; +impl Default for perf_event_attr { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl ::std::fmt::Debug for perf_event_attr { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + write!( + f, + "perf_event_attr {{ type: {:?}, a: {:?}, __bindgen_anon_1: {:?} }}", + self.type_, + self.a, + self.__bindgen_anon_1, + ) + } +} diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-opaque-template-instantiation.rs b/bindgen-tests/tests/expectations/tests/derive-debug-opaque-template-instantiation.rs new file mode 100644 index 0000000000..9d75e74d77 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-debug-opaque-template-instantiation.rs @@ -0,0 +1,20 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)] +#[repr(C)] +pub struct __BindgenOpaqueArray(pub T); +impl Default for __BindgenOpaqueArray<[T; N]> { + fn default() -> Self { + Self([::default(); N]) + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Instance { + pub val: __BindgenOpaqueArray<[u32; 50usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Instance"][::std::mem::size_of::() - 200usize]; + ["Alignment of Instance"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Instance::val"][::std::mem::offset_of!(Instance, val) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-opaque.rs b/bindgen-tests/tests/expectations/tests/derive-debug-opaque.rs new file mode 100644 index 0000000000..4ec1fb2a35 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-debug-opaque.rs @@ -0,0 +1,33 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)] +#[repr(C)] +pub struct __BindgenOpaqueArray(pub T); +impl Default for __BindgenOpaqueArray<[T; N]> { + fn default() -> Self { + Self([::default(); N]) + } +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Default, Copy, Clone)] +pub struct Opaque { + pub _bindgen_opaque_blob: __BindgenOpaqueArray<[u32; 41usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Opaque"][::std::mem::size_of::() - 164usize]; + ["Alignment of Opaque"][::std::mem::align_of::() - 4usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct OpaqueUser { + pub opaque: Opaque, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of OpaqueUser"][::std::mem::size_of::() - 164usize]; + ["Alignment of OpaqueUser"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: OpaqueUser::opaque", + ][::std::mem::offset_of!(OpaqueUser, opaque) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/derive-default-and-blocklist.rs b/bindgen-tests/tests/expectations/tests/derive-default-and-blocklist.rs new file mode 100644 index 0000000000..6ce99e5093 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-default-and-blocklist.rs @@ -0,0 +1,29 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub struct BlocklistMe(u8); +/** Because this type contains a blocklisted type, it should not derive + Default. Instead, we should emit a `mem::zeroed` implementation.*/ +#[repr(C)] +pub struct ShouldNotDeriveDefault { + pub a: BlocklistMe, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of ShouldNotDeriveDefault", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of ShouldNotDeriveDefault", + ][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: ShouldNotDeriveDefault::a", + ][::std::mem::offset_of!(ShouldNotDeriveDefault, a) - 0usize]; +}; +impl Default for ShouldNotDeriveDefault { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/derive-fn-ptr.rs b/bindgen-tests/tests/expectations/tests/derive-fn-ptr.rs new file mode 100644 index 0000000000..f4b09474ae --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-fn-ptr.rs @@ -0,0 +1,59 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type my_fun_t = ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + arg6: ::std::os::raw::c_int, + arg7: ::std::os::raw::c_int, + arg8: ::std::os::raw::c_int, + arg9: ::std::os::raw::c_int, + arg10: ::std::os::raw::c_int, + arg11: ::std::os::raw::c_int, + arg12: ::std::os::raw::c_int, + arg13: ::std::os::raw::c_int, + arg14: ::std::os::raw::c_int, + arg15: ::std::os::raw::c_int, + arg16: ::std::os::raw::c_int, + ), +>; +#[repr(C)] +#[derive(Default, Copy, Clone)] +pub struct Foo { + pub callback: my_fun_t, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 8usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Foo::callback"][::std::mem::offset_of!(Foo, callback) - 0usize]; +}; +pub type my_fun2_t = ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + arg6: ::std::os::raw::c_int, + arg7: ::std::os::raw::c_int, + arg8: ::std::os::raw::c_int, + arg9: ::std::os::raw::c_int, + arg10: ::std::os::raw::c_int, + arg11: ::std::os::raw::c_int, + arg12: ::std::os::raw::c_int, + ), +>; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Bar { + pub callback: my_fun2_t, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 8usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Bar::callback"][::std::mem::offset_of!(Bar, callback) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/derive-hash-and-blocklist.rs b/bindgen-tests/tests/expectations/tests/derive-hash-and-blocklist.rs new file mode 100644 index 0000000000..c52047e8b8 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-hash-and-blocklist.rs @@ -0,0 +1,28 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub struct BlocklistMe(u8); +/// Because this type contains a blocklisted type, it should not derive Hash. +#[repr(C)] +pub struct ShouldNotDeriveHash { + pub a: BlocklistMe, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of ShouldNotDeriveHash", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of ShouldNotDeriveHash", + ][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: ShouldNotDeriveHash::a", + ][::std::mem::offset_of!(ShouldNotDeriveHash, a) - 0usize]; +}; +impl Default for ShouldNotDeriveHash { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/derive-hash-blocklisting.rs b/bindgen-tests/tests/expectations/tests/derive-hash-blocklisting.rs new file mode 100644 index 0000000000..e3223f08d7 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-hash-blocklisting.rs @@ -0,0 +1,52 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Hash, Copy, Clone, PartialEq, Eq)] +pub struct Blocklisted { + t: T, + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, +} +/** This would derive(Hash, Eq, PartialEq) if it didn't contain a blocklisted type, + causing us to conservatively avoid deriving hash/Eq/PartialEq for it.*/ +#[repr(C)] +pub struct AllowlistedOne { + pub a: Blocklisted<::std::os::raw::c_int>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of AllowlistedOne"][::std::mem::size_of::() - 4usize]; + ["Alignment of AllowlistedOne"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: AllowlistedOne::a", + ][::std::mem::offset_of!(AllowlistedOne, a) - 0usize]; +}; +impl Default for AllowlistedOne { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +/// This can't derive(Hash/Eq) even if it didn't contain a blocklisted type. +#[repr(C)] +pub struct AllowlistedTwo { + pub b: Blocklisted, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of AllowlistedTwo"][::std::mem::size_of::() - 4usize]; + ["Alignment of AllowlistedTwo"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: AllowlistedTwo::b", + ][::std::mem::offset_of!(AllowlistedTwo, b) - 0usize]; +}; +impl Default for AllowlistedTwo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-anon-struct-float.rs b/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-anon-struct-float.rs new file mode 100644 index 0000000000..2d66015fe7 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-anon-struct-float.rs @@ -0,0 +1,32 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +/// A struct containing a struct containing a float that cannot derive Hash/Eq/Ord but can derive PartialEq/PartialOrd +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, PartialOrd, PartialEq)] +pub struct foo { + pub bar: foo__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, PartialOrd, PartialEq)] +pub struct foo__bindgen_ty_1 { + pub a: f32, + pub b: f32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo__bindgen_ty_1"][::std::mem::size_of::() - 8usize]; + [ + "Alignment of foo__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: foo__bindgen_ty_1::a", + ][::std::mem::offset_of!(foo__bindgen_ty_1, a) - 0usize]; + [ + "Offset of field: foo__bindgen_ty_1::b", + ][::std::mem::offset_of!(foo__bindgen_ty_1, b) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 8usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::bar"][::std::mem::offset_of!(foo, bar) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-float-array.rs b/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-float-array.rs new file mode 100644 index 0000000000..254a50b3e3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-float-array.rs @@ -0,0 +1,13 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +/// A struct containing an array of floats that cannot derive Hash/Eq/Ord but can derive PartialEq/PartialOrd +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, PartialOrd, PartialEq)] +pub struct foo { + pub bar: [f32; 3usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 12usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::bar"][::std::mem::offset_of!(foo, bar) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-incomplete-array.rs b/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-incomplete-array.rs new file mode 100644 index 0000000000..2588a49eed --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-incomplete-array.rs @@ -0,0 +1,80 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Default)] +pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); +impl __IncompleteArrayField { + #[inline] + pub const fn new() -> Self { + __IncompleteArrayField(::std::marker::PhantomData, []) + } + #[inline] + pub fn as_ptr(&self) -> *const T { + self as *const _ as *const T + } + #[inline] + pub fn as_mut_ptr(&mut self) -> *mut T { + self as *mut _ as *mut T + } + #[inline] + pub unsafe fn as_slice(&self, len: usize) -> &[T] { + ::std::slice::from_raw_parts(self.as_ptr(), len) + } + #[inline] + pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { + ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) + } +} +impl ::std::fmt::Debug for __IncompleteArrayField { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + fmt.write_str("__IncompleteArrayField") + } +} +#[repr(C)] +#[derive(Debug, Default)] +pub struct test { + pub a: ::std::os::raw::c_int, + pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of test"][::std::mem::size_of::() - 4usize]; + ["Alignment of test"][::std::mem::align_of::() - 4usize]; + ["Offset of field: test::a"][::std::mem::offset_of!(test, a) - 0usize]; + [ + "Offset of field: test::zero_length_array", + ][::std::mem::offset_of!(test, zero_length_array) - 4usize]; +}; +#[repr(C)] +#[derive(Debug, Default)] +pub struct test2 { + pub a: ::std::os::raw::c_int, + pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of test2"][::std::mem::size_of::() - 4usize]; + ["Alignment of test2"][::std::mem::align_of::() - 4usize]; + ["Offset of field: test2::a"][::std::mem::offset_of!(test2, a) - 0usize]; + [ + "Offset of field: test2::incomplete_array", + ][::std::mem::offset_of!(test2, incomplete_array) - 4usize]; +}; +#[repr(C)] +#[derive(Debug, Default)] +pub struct test3 { + pub a: ::std::os::raw::c_int, + pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>, + pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of test3"][::std::mem::size_of::() - 4usize]; + ["Alignment of test3"][::std::mem::align_of::() - 4usize]; + ["Offset of field: test3::a"][::std::mem::offset_of!(test3, a) - 0usize]; + [ + "Offset of field: test3::zero_length_array", + ][::std::mem::offset_of!(test3, zero_length_array) - 4usize]; + [ + "Offset of field: test3::incomplete_array", + ][::std::mem::offset_of!(test3, incomplete_array) - 4usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-pointer.rs b/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-pointer.rs new file mode 100644 index 0000000000..5240d969db --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-pointer.rs @@ -0,0 +1,92 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +/// Pointers can derive Hash/PartialOrd/Ord/PartialEq/Eq +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)] +pub struct ConstPtrMutObj { + pub bar: *mut ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ConstPtrMutObj"][::std::mem::size_of::() - 8usize]; + ["Alignment of ConstPtrMutObj"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: ConstPtrMutObj::bar", + ][::std::mem::offset_of!(ConstPtrMutObj, bar) - 0usize]; +}; +impl Default for ConstPtrMutObj { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)] +pub struct MutPtrMutObj { + pub bar: *mut ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of MutPtrMutObj"][::std::mem::size_of::() - 8usize]; + ["Alignment of MutPtrMutObj"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: MutPtrMutObj::bar", + ][::std::mem::offset_of!(MutPtrMutObj, bar) - 0usize]; +}; +impl Default for MutPtrMutObj { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)] +pub struct MutPtrConstObj { + pub bar: *const ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of MutPtrConstObj"][::std::mem::size_of::() - 8usize]; + ["Alignment of MutPtrConstObj"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: MutPtrConstObj::bar", + ][::std::mem::offset_of!(MutPtrConstObj, bar) - 0usize]; +}; +impl Default for MutPtrConstObj { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)] +pub struct ConstPtrConstObj { + pub bar: *const ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ConstPtrConstObj"][::std::mem::size_of::() - 8usize]; + [ + "Alignment of ConstPtrConstObj", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: ConstPtrConstObj::bar", + ][::std::mem::offset_of!(ConstPtrConstObj, bar) - 0usize]; +}; +impl Default for ConstPtrConstObj { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/derive-hash-template-def-float.rs b/bindgen-tests/tests/expectations/tests/derive-hash-template-def-float.rs new file mode 100644 index 0000000000..af09533cca --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-hash-template-def-float.rs @@ -0,0 +1,18 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +/// Template definition containing a float, which cannot derive Hash/Eq/Ord but can derive PartialEq/PartialOrd. +#[repr(C)] +#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)] +pub struct foo { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub data: T, + pub b: f32, +} +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/derive-hash-template-inst-float.rs b/bindgen-tests/tests/expectations/tests/derive-hash-template-inst-float.rs new file mode 100644 index 0000000000..10ed002e6e --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-hash-template-inst-float.rs @@ -0,0 +1,77 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +/// Template definition that doesn't contain float can derive Hash/PartialOrd/Ord/PartialEq/Eq +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)] +pub struct foo { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub data: T, +} +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +/// Can derive Hash/PartialOrd/Ord/PartialEq/Eq when instantiated with int +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)] +pub struct IntStr { + pub a: foo<::std::os::raw::c_int>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of IntStr"][::std::mem::size_of::() - 4usize]; + ["Alignment of IntStr"][::std::mem::align_of::() - 4usize]; + ["Offset of field: IntStr::a"][::std::mem::offset_of!(IntStr, a) - 0usize]; +}; +impl Default for IntStr { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +/// Cannot derive Hash/Eq/Ord when instantiated with float but can derive PartialEq/PartialOrd +#[repr(C)] +#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)] +pub struct FloatStr { + pub a: foo, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of FloatStr"][::std::mem::size_of::() - 4usize]; + ["Alignment of FloatStr"][::std::mem::align_of::() - 4usize]; + ["Offset of field: FloatStr::a"][::std::mem::offset_of!(FloatStr, a) - 0usize]; +}; +impl Default for FloatStr { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: foo_open0_int_close0", + ][::std::mem::size_of::>() - 4usize]; + [ + "Align of template specialization: foo_open0_int_close0", + ][::std::mem::align_of::>() - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: foo_open0_float_close0", + ][::std::mem::size_of::>() - 4usize]; + [ + "Align of template specialization: foo_open0_float_close0", + ][::std::mem::align_of::>() - 4usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/derive-partialeq-and-blocklist.rs b/bindgen-tests/tests/expectations/tests/derive-partialeq-and-blocklist.rs new file mode 100644 index 0000000000..d24981061c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-partialeq-and-blocklist.rs @@ -0,0 +1,29 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub struct BlocklistMe(u8); +/** Because this type contains a blocklisted type, it should not derive + PartialEq.*/ +#[repr(C)] +pub struct ShouldNotDerivePartialEq { + pub a: BlocklistMe, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of ShouldNotDerivePartialEq", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of ShouldNotDerivePartialEq", + ][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: ShouldNotDerivePartialEq::a", + ][::std::mem::offset_of!(ShouldNotDerivePartialEq, a) - 0usize]; +}; +impl Default for ShouldNotDerivePartialEq { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/derive-partialeq-anonfield.rs b/bindgen-tests/tests/expectations/tests/derive-partialeq-anonfield.rs new file mode 100644 index 0000000000..c4eb08df60 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-partialeq-anonfield.rs @@ -0,0 +1,45 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[repr(align(64))] +#[derive(Copy, Clone)] +pub struct rte_mbuf { + pub __bindgen_anon_1: rte_mbuf__bindgen_ty_1, +} +#[repr(C)] +#[repr(align(1))] +#[derive(Copy, Clone)] +pub struct rte_mbuf__bindgen_ty_1 { + pub bindgen_union_field: [u8; 0usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_mbuf__bindgen_ty_1", + ][::std::mem::size_of::() - 0usize]; + [ + "Alignment of rte_mbuf__bindgen_ty_1", + ][::std::mem::align_of::() - 1usize]; +}; +impl Default for rte_mbuf__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_mbuf"][::std::mem::size_of::() - 0usize]; + ["Alignment of rte_mbuf"][::std::mem::align_of::() - 64usize]; +}; +impl Default for rte_mbuf { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/derive-partialeq-base.rs b/bindgen-tests/tests/expectations/tests/derive-partialeq-base.rs new file mode 100644 index 0000000000..3ca262fe36 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-partialeq-base.rs @@ -0,0 +1,44 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone, PartialEq)] +pub struct Base { + pub large: [::std::os::raw::c_int; 33usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Base"][::std::mem::size_of::() - 132usize]; + ["Alignment of Base"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Base::large"][::std::mem::offset_of!(Base, large) - 0usize]; +}; +impl Default for Base { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone, PartialEq)] +pub struct ShouldDerivePartialEq { + pub _base: Base, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of ShouldDerivePartialEq", + ][::std::mem::size_of::() - 132usize]; + [ + "Alignment of ShouldDerivePartialEq", + ][::std::mem::align_of::() - 4usize]; +}; +impl Default for ShouldDerivePartialEq { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/derive-partialeq-bitfield.rs b/bindgen-tests/tests/expectations/tests/derive-partialeq-bitfield.rs new file mode 100644 index 0000000000..b8da88e2a7 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-partialeq-bitfield.rs @@ -0,0 +1,263 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone, PartialEq)] +pub struct C { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub large_array: [::std::os::raw::c_int; 50usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C"][::std::mem::size_of::() - 204usize]; + ["Alignment of C"][::std::mem::align_of::() - 4usize]; + ["Offset of field: C::large_array"][::std::mem::offset_of!(C, large_array) - 4usize]; +}; +impl Default for C { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl C { + #[inline] + pub fn a(&self) -> bool { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_a(&mut self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn a_raw(this: *const Self) -> bool { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_a_raw(this: *mut Self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn b(&self) -> bool { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8) } + } + #[inline] + pub fn set_b(&mut self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 7u8, val as u64) + } + } + #[inline] + pub unsafe fn b_raw(this: *const Self) -> bool { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 7u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_b_raw(this: *mut Self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 7u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(a: bool, b: bool) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let a: u8 = unsafe { ::std::mem::transmute(a) }; + a as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 7u8, + { + let b: u8 = unsafe { ::std::mem::transmute(b) }; + b as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/derive-partialeq-core.rs b/bindgen-tests/tests/expectations/tests/derive-partialeq-core.rs new file mode 100644 index 0000000000..9a36b8f8c7 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-partialeq-core.rs @@ -0,0 +1,24 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +extern crate core; +#[repr(C)] +#[derive(Debug, Copy, Clone, PartialEq)] +pub struct C { + pub large_array: [::core::ffi::c_int; 420usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C"][::core::mem::size_of::() - 1680usize]; + ["Alignment of C"][::core::mem::align_of::() - 4usize]; + [ + "Offset of field: C::large_array", + ][::core::mem::offset_of!(C, large_array) - 0usize]; +}; +impl Default for C { + fn default() -> Self { + let mut s = ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/derive-partialeq-pointer.rs b/bindgen-tests/tests/expectations/tests/derive-partialeq-pointer.rs new file mode 100644 index 0000000000..3e48e5d8ce --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-partialeq-pointer.rs @@ -0,0 +1,79 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Bar { + pub b: *mut a, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 8usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Bar::b"][::std::mem::offset_of!(Bar, b) - 0usize]; +}; +impl Default for Bar { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct c { + pub __bindgen_anon_1: c__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union c__bindgen_ty_1 { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of c__bindgen_ty_1"][::std::mem::size_of::() - 1usize]; + ["Alignment of c__bindgen_ty_1"][::std::mem::align_of::() - 1usize]; +}; +impl Default for c__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of c"][::std::mem::size_of::() - 1usize]; + ["Alignment of c"][::std::mem::align_of::() - 1usize]; +}; +impl Default for c { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct a { + pub d: c, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of a"][::std::mem::size_of::() - 1usize]; + ["Alignment of a"][::std::mem::align_of::() - 1usize]; + ["Offset of field: a::d"][::std::mem::offset_of!(a, d) - 0usize]; +}; +impl Default for a { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/derive-partialeq-union.rs b/bindgen-tests/tests/expectations/tests/derive-partialeq-union.rs new file mode 100644 index 0000000000..0365c765eb --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/derive-partialeq-union.rs @@ -0,0 +1,32 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +/// Deriving PartialEq for rust unions is not supported. +#[repr(C)] +#[derive(Copy, Clone)] +pub union ShouldNotDerivePartialEq { + pub a: ::std::os::raw::c_char, + pub b: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of ShouldNotDerivePartialEq", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of ShouldNotDerivePartialEq", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: ShouldNotDerivePartialEq::a", + ][::std::mem::offset_of!(ShouldNotDerivePartialEq, a) - 0usize]; + [ + "Offset of field: ShouldNotDerivePartialEq::b", + ][::std::mem::offset_of!(ShouldNotDerivePartialEq, b) - 0usize]; +}; +impl Default for ShouldNotDerivePartialEq { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/disable-namespacing.rs b/bindgen-tests/tests/expectations/tests/disable-namespacing.rs new file mode 100644 index 0000000000..4d9b6a082d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/disable-namespacing.rs @@ -0,0 +1,2 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type Baz = ::std::os::raw::c_int; diff --git a/bindgen-tests/tests/expectations/tests/disable-nested-struct-naming.rs b/bindgen-tests/tests/expectations/tests/disable-nested-struct-naming.rs new file mode 100644 index 0000000000..757e0481aa --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/disable-nested-struct-naming.rs @@ -0,0 +1,122 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct foo { + pub b1: bar1, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct bar1 { + pub x1: ::std::os::raw::c_int, + pub b2: bar1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct bar1__bindgen_ty_1 { + pub x2: ::std::os::raw::c_int, + pub b3: bar1__bindgen_ty_1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct bar1__bindgen_ty_1__bindgen_ty_1 { + pub x3: ::std::os::raw::c_int, + pub b4: bar4, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct bar4 { + pub x4: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of bar4"][::std::mem::size_of::() - 4usize]; + ["Alignment of bar4"][::std::mem::align_of::() - 4usize]; + ["Offset of field: bar4::x4"][::std::mem::offset_of!(bar4, x4) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of bar1__bindgen_ty_1__bindgen_ty_1", + ][::std::mem::size_of::() - 8usize]; + [ + "Alignment of bar1__bindgen_ty_1__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: bar1__bindgen_ty_1__bindgen_ty_1::x3", + ][::std::mem::offset_of!(bar1__bindgen_ty_1__bindgen_ty_1, x3) - 0usize]; + [ + "Offset of field: bar1__bindgen_ty_1__bindgen_ty_1::b4", + ][::std::mem::offset_of!(bar1__bindgen_ty_1__bindgen_ty_1, b4) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of bar1__bindgen_ty_1", + ][::std::mem::size_of::() - 12usize]; + [ + "Alignment of bar1__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: bar1__bindgen_ty_1::x2", + ][::std::mem::offset_of!(bar1__bindgen_ty_1, x2) - 0usize]; + [ + "Offset of field: bar1__bindgen_ty_1::b3", + ][::std::mem::offset_of!(bar1__bindgen_ty_1, b3) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of bar1"][::std::mem::size_of::() - 16usize]; + ["Alignment of bar1"][::std::mem::align_of::() - 4usize]; + ["Offset of field: bar1::x1"][::std::mem::offset_of!(bar1, x1) - 0usize]; + ["Offset of field: bar1::b2"][::std::mem::offset_of!(bar1, b2) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 16usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::b1"][::std::mem::offset_of!(foo, b1) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _bindgen_ty_1 { + pub anon2: _bindgen_ty_1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _bindgen_ty_1__bindgen_ty_1 { + pub b: baz, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct baz { + pub x: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of baz"][::std::mem::size_of::() - 4usize]; + ["Alignment of baz"][::std::mem::align_of::() - 4usize]; + ["Offset of field: baz::x"][::std::mem::offset_of!(baz, x) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of _bindgen_ty_1__bindgen_ty_1", + ][::std::mem::size_of::<_bindgen_ty_1__bindgen_ty_1>() - 4usize]; + [ + "Alignment of _bindgen_ty_1__bindgen_ty_1", + ][::std::mem::align_of::<_bindgen_ty_1__bindgen_ty_1>() - 4usize]; + [ + "Offset of field: _bindgen_ty_1__bindgen_ty_1::b", + ][::std::mem::offset_of!(_bindgen_ty_1__bindgen_ty_1, b) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _bindgen_ty_1"][::std::mem::size_of::<_bindgen_ty_1>() - 4usize]; + ["Alignment of _bindgen_ty_1"][::std::mem::align_of::<_bindgen_ty_1>() - 4usize]; + [ + "Offset of field: _bindgen_ty_1::anon2", + ][::std::mem::offset_of!(_bindgen_ty_1, anon2) - 0usize]; +}; +unsafe extern "C" { + pub static mut anon1: _bindgen_ty_1; +} diff --git a/bindgen-tests/tests/expectations/tests/disable-untagged-union.rs b/bindgen-tests/tests/expectations/tests/disable-untagged-union.rs new file mode 100644 index 0000000000..60636280e4 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/disable-untagged-union.rs @@ -0,0 +1,58 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct __BindgenUnionField(::std::marker::PhantomData); +impl __BindgenUnionField { + #[inline] + pub const fn new() -> Self { + __BindgenUnionField(::std::marker::PhantomData) + } + #[inline] + pub unsafe fn as_ref(&self) -> &T { + ::std::mem::transmute(self) + } + #[inline] + pub unsafe fn as_mut(&mut self) -> &mut T { + ::std::mem::transmute(self) + } +} +impl ::std::default::Default for __BindgenUnionField { + #[inline] + fn default() -> Self { + Self::new() + } +} +impl ::std::clone::Clone for __BindgenUnionField { + #[inline] + fn clone(&self) -> Self { + *self + } +} +impl ::std::marker::Copy for __BindgenUnionField {} +impl ::std::fmt::Debug for __BindgenUnionField { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + fmt.write_str("__BindgenUnionField") + } +} +impl ::std::hash::Hash for __BindgenUnionField { + fn hash(&self, _state: &mut H) {} +} +impl ::std::cmp::PartialEq for __BindgenUnionField { + fn eq(&self, _other: &__BindgenUnionField) -> bool { + true + } +} +impl ::std::cmp::Eq for __BindgenUnionField {} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub bar: __BindgenUnionField<::std::os::raw::c_int>, + pub baz: __BindgenUnionField<::std::os::raw::c_uint>, + pub bindgen_union_field: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Foo::bar"][::std::mem::offset_of!(Foo, bar) - 0usize]; + ["Offset of field: Foo::baz"][::std::mem::offset_of!(Foo, baz) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/divide-by-zero-in-struct-layout.rs b/bindgen-tests/tests/expectations/tests/divide-by-zero-in-struct-layout.rs new file mode 100644 index 0000000000..37139d3136 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/divide-by-zero-in-struct-layout.rs @@ -0,0 +1,186 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct WithBitfield { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub a: ::std::os::raw::c_uint, +} +impl WithBitfield { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + } +} +#[repr(C, packed)] +#[derive(Debug, Default, Copy, Clone)] +pub struct WithBitfieldAndAttrPacked { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub a: ::std::os::raw::c_uint, +} +impl WithBitfieldAndAttrPacked { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + } +} +#[repr(C, packed)] +#[derive(Debug, Default, Copy, Clone)] +pub struct WithBitfieldAndPacked { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub a: ::std::os::raw::c_uint, +} +impl WithBitfieldAndPacked { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/do-not-derive-copy.rs b/bindgen-tests/tests/expectations/tests/do-not-derive-copy.rs new file mode 100644 index 0000000000..29ca6d6acf --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/do-not-derive-copy.rs @@ -0,0 +1,18 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default)] +pub struct WouldBeCopyButWeAreNotDerivingCopy { + pub x: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of WouldBeCopyButWeAreNotDerivingCopy", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of WouldBeCopyButWeAreNotDerivingCopy", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: WouldBeCopyButWeAreNotDerivingCopy::x", + ][::std::mem::offset_of!(WouldBeCopyButWeAreNotDerivingCopy, x) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/doggo-or-null.rs b/bindgen-tests/tests/expectations/tests/doggo-or-null.rs new file mode 100644 index 0000000000..972da871d3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/doggo-or-null.rs @@ -0,0 +1,48 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq)] +pub struct Doggo { + pub x: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Doggo"][::std::mem::size_of::() - 4usize]; + ["Alignment of Doggo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Doggo::x"][::std::mem::offset_of!(Doggo, x) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq)] +pub struct Null { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Null"][::std::mem::size_of::() - 1usize]; + ["Alignment of Null"][::std::mem::align_of::() - 1usize]; +}; +/** This type is an opaque union. Unions can't derive anything interesting like + Debug or Default, even if their layout can, because it would require knowing + which variant is in use. Opaque unions still end up as a `union` in the Rust + bindings, but they just have one variant. Even so, can't derive. We should + probably emit an opaque struct for opaque unions... but until then, we have + this test to make sure that opaque unions don't derive and still compile.*/ +#[repr(C)] +#[repr(align(4))] +#[derive(Copy, Clone)] +pub union DoggoOrNull { + pub _bindgen_opaque_blob: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of DoggoOrNull"][::std::mem::size_of::() - 4usize]; + ["Alignment of DoggoOrNull"][::std::mem::align_of::() - 4usize]; +}; +impl Default for DoggoOrNull { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/dupe-enum-variant-in-namespace.rs b/bindgen-tests/tests/expectations/tests/dupe-enum-variant-in-namespace.rs new file mode 100644 index 0000000000..d521bcc17b --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/dupe-enum-variant-in-namespace.rs @@ -0,0 +1,22 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod foo { + #[allow(unused_imports)] + use self::super::super::root; + impl root::foo::Bar { + pub const Foo1: root::foo::Bar = Bar::Foo; + } + impl root::foo::Bar { + pub const Foo3: root::foo::Bar = Bar::Foo2; + } + #[repr(u32)] + #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] + pub enum Bar { + Foo = 0, + Foo2 = 1, + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/duplicated-definition-count.rs b/bindgen-tests/tests/expectations/tests/duplicated-definition-count.rs new file mode 100644 index 0000000000..86e1edbbf9 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/duplicated-definition-count.rs @@ -0,0 +1,53 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct BitStream { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of BitStream"][::std::mem::size_of::() - 1usize]; + ["Alignment of BitStream"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN9BitStream5WriteEPKcj"] + pub fn BitStream_Write( + this: *mut BitStream, + inputByteArray: *const ::std::os::raw::c_char, + numberOfBytes: ::std::os::raw::c_uint, + ); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN9BitStream5WriteEPS_j"] + pub fn BitStream_Write1( + this: *mut BitStream, + bitStream: *mut BitStream, + numberOfBits: ::std::os::raw::c_uint, + ); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN9BitStream6Write1Ev"] + pub fn BitStream_Write11(this: *mut BitStream); +} +impl BitStream { + #[inline] + pub unsafe fn Write( + &mut self, + inputByteArray: *const ::std::os::raw::c_char, + numberOfBytes: ::std::os::raw::c_uint, + ) { + BitStream_Write(self, inputByteArray, numberOfBytes) + } + #[inline] + pub unsafe fn Write1( + &mut self, + bitStream: *mut BitStream, + numberOfBits: ::std::os::raw::c_uint, + ) { + BitStream_Write1(self, bitStream, numberOfBits) + } + #[inline] + pub unsafe fn Write11(&mut self) { + BitStream_Write11(self) + } +} diff --git a/bindgen-tests/tests/expectations/tests/duplicated-namespaces-definitions.rs b/bindgen-tests/tests/expectations/tests/duplicated-namespaces-definitions.rs new file mode 100644 index 0000000000..775a21ac30 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/duplicated-namespaces-definitions.rs @@ -0,0 +1,47 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod foo { + #[allow(unused_imports)] + use self::super::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Bar { + pub foo: ::std::os::raw::c_int, + pub baz: bool, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 8usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Bar::foo"][::std::mem::offset_of!(Bar, foo) - 0usize]; + ["Offset of field: Bar::baz"][::std::mem::offset_of!(Bar, baz) - 4usize]; + }; + } + pub mod bar { + #[allow(unused_imports)] + use self::super::super::root; + #[repr(C)] + #[derive(Debug, Copy, Clone)] + pub struct Foo { + pub ptr: *mut root::foo::Bar, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 8usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Foo::ptr"][::std::mem::offset_of!(Foo, ptr) - 0usize]; + }; + impl Default for Foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/duplicated-namespaces.rs b/bindgen-tests/tests/expectations/tests/duplicated-namespaces.rs new file mode 100644 index 0000000000..c652d151b8 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/duplicated-namespaces.rs @@ -0,0 +1,6 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; +} diff --git a/bindgen-tests/tests/expectations/tests/duplicated_constants_in_ns.rs b/bindgen-tests/tests/expectations/tests/duplicated_constants_in_ns.rs new file mode 100644 index 0000000000..2f676374ae --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/duplicated_constants_in_ns.rs @@ -0,0 +1,16 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod foo { + #[allow(unused_imports)] + use self::super::super::root; + pub const FOO: ::std::os::raw::c_int = 4; + } + pub mod bar { + #[allow(unused_imports)] + use self::super::super::root; + pub const FOO: ::std::os::raw::c_int = 5; + } +} diff --git a/bindgen-tests/tests/expectations/tests/dynamic_loading_attributes.rs b/bindgen-tests/tests/expectations/tests/dynamic_loading_attributes.rs new file mode 100644 index 0000000000..a1fb1b0cc1 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/dynamic_loading_attributes.rs @@ -0,0 +1,43 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub struct TestLib { + __library: ::libloading::Library, + pub foo: unsafe extern "C" fn( + x: ::std::os::raw::c_int, + y: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + pub baz: unsafe extern "C" fn() -> ::std::os::raw::c_int, +} +impl TestLib { + pub unsafe fn new

(path: P) -> Result + where + P: AsRef<::std::ffi::OsStr>, + { + let library = ::libloading::Library::new(path)?; + Self::from_library(library) + } + pub unsafe fn from_library(library: L) -> Result + where + L: Into<::libloading::Library>, + { + let __library = library.into(); + let foo = __library.get(b"foo\0").map(|sym| *sym)?; + let baz = __library.get(b"baz\0").map(|sym| *sym)?; + Ok(TestLib { __library, foo, baz }) + } + #[must_use] + /** @brief A function + + @param x + @param y + @return int*/ + pub unsafe fn foo( + &self, + x: ::std::os::raw::c_int, + y: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int { + (self.foo)(x, y) + } + pub unsafe fn baz(&self) -> ::std::os::raw::c_int { + (self.baz)() + } +} diff --git a/bindgen-tests/tests/expectations/tests/dynamic_loading_required.rs b/bindgen-tests/tests/expectations/tests/dynamic_loading_required.rs new file mode 100644 index 0000000000..5c929ffc3d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/dynamic_loading_required.rs @@ -0,0 +1,49 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub struct TestLib { + __library: ::libloading::Library, + pub foo: unsafe extern "C" fn( + x: ::std::os::raw::c_int, + y: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + pub bar: unsafe extern "C" fn( + x: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + pub baz: unsafe extern "C" fn() -> ::std::os::raw::c_int, +} +impl TestLib { + pub unsafe fn new

(path: P) -> Result + where + P: AsRef<::std::ffi::OsStr>, + { + let library = ::libloading::Library::new(path)?; + Self::from_library(library) + } + pub unsafe fn from_library(library: L) -> Result + where + L: Into<::libloading::Library>, + { + let __library = library.into(); + let foo = __library.get(b"foo\0").map(|sym| *sym)?; + let bar = __library.get(b"bar\0").map(|sym| *sym)?; + let baz = __library.get(b"baz\0").map(|sym| *sym)?; + Ok(TestLib { + __library, + foo, + bar, + baz, + }) + } + pub unsafe fn foo( + &self, + x: ::std::os::raw::c_int, + y: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int { + (self.foo)(x, y) + } + pub unsafe fn bar(&self, x: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int { + (self.bar)(x) + } + pub unsafe fn baz(&self) -> ::std::os::raw::c_int { + (self.baz)() + } +} diff --git a/bindgen-tests/tests/expectations/tests/dynamic_loading_simple.rs b/bindgen-tests/tests/expectations/tests/dynamic_loading_simple.rs new file mode 100644 index 0000000000..9a4cfaf570 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/dynamic_loading_simple.rs @@ -0,0 +1,56 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub struct TestLib { + __library: ::libloading::Library, + pub foo: Result< + unsafe extern "C" fn( + x: ::std::os::raw::c_int, + y: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + ::libloading::Error, + >, + pub bar: Result< + unsafe extern "C" fn(x: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + ::libloading::Error, + >, + pub baz: Result< + unsafe extern "C" fn() -> ::std::os::raw::c_int, + ::libloading::Error, + >, +} +impl TestLib { + pub unsafe fn new

(path: P) -> Result + where + P: AsRef<::std::ffi::OsStr>, + { + let library = ::libloading::Library::new(path)?; + Self::from_library(library) + } + pub unsafe fn from_library(library: L) -> Result + where + L: Into<::libloading::Library>, + { + let __library = library.into(); + let foo = __library.get(b"foo\0").map(|sym| *sym); + let bar = __library.get(b"bar\0").map(|sym| *sym); + let baz = __library.get(b"baz\0").map(|sym| *sym); + Ok(TestLib { + __library, + foo, + bar, + baz, + }) + } + pub unsafe fn foo( + &self, + x: ::std::os::raw::c_int, + y: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int { + (self.foo.as_ref().expect("Expected function, got error."))(x, y) + } + pub unsafe fn bar(&self, x: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int { + (self.bar.as_ref().expect("Expected function, got error."))(x) + } + pub unsafe fn baz(&self) -> ::std::os::raw::c_int { + (self.baz.as_ref().expect("Expected function, got error."))() + } +} diff --git a/bindgen-tests/tests/expectations/tests/dynamic_loading_template.rs b/bindgen-tests/tests/expectations/tests/dynamic_loading_template.rs new file mode 100644 index 0000000000..1f63a7893f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/dynamic_loading_template.rs @@ -0,0 +1,33 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub struct TestLib { + __library: ::libloading::Library, + pub foo: Result< + unsafe extern "C" fn(x: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + ::libloading::Error, + >, + pub foo1: Result f32, ::libloading::Error>, +} +impl TestLib { + pub unsafe fn new

(path: P) -> Result + where + P: AsRef<::std::ffi::OsStr>, + { + let library = ::libloading::Library::new(path)?; + Self::from_library(library) + } + pub unsafe fn from_library(library: L) -> Result + where + L: Into<::libloading::Library>, + { + let __library = library.into(); + let foo = __library.get(b"_Z3fooIiET_S0_\0").map(|sym| *sym); + let foo1 = __library.get(b"_Z3fooIfET_S0_\0").map(|sym| *sym); + Ok(TestLib { __library, foo, foo1 }) + } + pub unsafe fn foo(&self, x: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + (self.foo.as_ref().expect("Expected function, got error."))(x) + } + pub unsafe fn foo1(&self, x: f32) -> f32 { + (self.foo1.as_ref().expect("Expected function, got error."))(x) + } +} diff --git a/bindgen-tests/tests/expectations/tests/dynamic_loading_variable_required.rs b/bindgen-tests/tests/expectations/tests/dynamic_loading_variable_required.rs new file mode 100644 index 0000000000..a96efbe546 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/dynamic_loading_variable_required.rs @@ -0,0 +1,32 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub struct TestLib { + __library: ::libloading::Library, + pub foo: *mut ::std::os::raw::c_int, + pub baz: *mut *mut ::std::os::raw::c_int, +} +impl TestLib { + pub unsafe fn new

(path: P) -> Result + where + P: AsRef<::std::ffi::OsStr>, + { + let library = ::libloading::Library::new(path)?; + Self::from_library(library) + } + pub unsafe fn from_library(library: L) -> Result + where + L: Into<::libloading::Library>, + { + let __library = library.into(); + let foo = __library.get::<*mut ::std::os::raw::c_int>(b"foo\0").map(|sym| *sym)?; + let baz = __library + .get::<*mut *mut ::std::os::raw::c_int>(b"baz\0") + .map(|sym| *sym)?; + Ok(TestLib { __library, foo, baz }) + } + pub unsafe fn foo(&self) -> *mut ::std::os::raw::c_int { + self.foo + } + pub unsafe fn baz(&self) -> *mut *mut ::std::os::raw::c_int { + self.baz + } +} diff --git a/bindgen-tests/tests/expectations/tests/dynamic_loading_variable_simple.rs b/bindgen-tests/tests/expectations/tests/dynamic_loading_variable_simple.rs new file mode 100644 index 0000000000..ced70dbdba --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/dynamic_loading_variable_simple.rs @@ -0,0 +1,32 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub struct TestLib { + __library: ::libloading::Library, + pub foo: Result<*mut ::std::os::raw::c_int, ::libloading::Error>, + pub baz: Result<*mut *mut ::std::os::raw::c_int, ::libloading::Error>, +} +impl TestLib { + pub unsafe fn new

(path: P) -> Result + where + P: AsRef<::std::ffi::OsStr>, + { + let library = ::libloading::Library::new(path)?; + Self::from_library(library) + } + pub unsafe fn from_library(library: L) -> Result + where + L: Into<::libloading::Library>, + { + let __library = library.into(); + let foo = __library.get::<*mut ::std::os::raw::c_int>(b"foo\0").map(|sym| *sym); + let baz = __library + .get::<*mut *mut ::std::os::raw::c_int>(b"baz\0") + .map(|sym| *sym); + Ok(TestLib { __library, foo, baz }) + } + pub unsafe fn foo(&self) -> *mut ::std::os::raw::c_int { + *self.foo.as_ref().expect("Expected variable, got error.") + } + pub unsafe fn baz(&self) -> *mut *mut ::std::os::raw::c_int { + *self.baz.as_ref().expect("Expected variable, got error.") + } +} diff --git a/bindgen-tests/tests/expectations/tests/dynamic_loading_variable_with_allowlist.rs b/bindgen-tests/tests/expectations/tests/dynamic_loading_variable_with_allowlist.rs new file mode 100644 index 0000000000..3f29e73814 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/dynamic_loading_variable_with_allowlist.rs @@ -0,0 +1,30 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub struct TestLib { + __library: ::libloading::Library, + pub foo: Result<*mut ::std::os::raw::c_int, ::libloading::Error>, + pub bar: Result<*mut ::std::os::raw::c_int, ::libloading::Error>, +} +impl TestLib { + pub unsafe fn new

(path: P) -> Result + where + P: AsRef<::std::ffi::OsStr>, + { + let library = ::libloading::Library::new(path)?; + Self::from_library(library) + } + pub unsafe fn from_library(library: L) -> Result + where + L: Into<::libloading::Library>, + { + let __library = library.into(); + let foo = __library.get::<*mut ::std::os::raw::c_int>(b"foo\0").map(|sym| *sym); + let bar = __library.get::<*mut ::std::os::raw::c_int>(b"bar\0").map(|sym| *sym); + Ok(TestLib { __library, foo, bar }) + } + pub unsafe fn foo(&self) -> *mut ::std::os::raw::c_int { + *self.foo.as_ref().expect("Expected variable, got error.") + } + pub unsafe fn bar(&self) -> *mut ::std::os::raw::c_int { + *self.bar.as_ref().expect("Expected variable, got error.") + } +} diff --git a/bindgen-tests/tests/expectations/tests/dynamic_loading_with_allowlist.rs b/bindgen-tests/tests/expectations/tests/dynamic_loading_with_allowlist.rs new file mode 100644 index 0000000000..34ebe8d9a5 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/dynamic_loading_with_allowlist.rs @@ -0,0 +1,46 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub struct TestLib { + __library: ::libloading::Library, + pub foo: Result< + unsafe extern "C" fn(x: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + ::libloading::Error, + >, + pub baz: Result< + unsafe extern "C" fn(x: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + ::libloading::Error, + >, + pub bazz: Result< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, + ::libloading::Error, + >, +} +impl TestLib { + pub unsafe fn new

(path: P) -> Result + where + P: AsRef<::std::ffi::OsStr>, + { + let library = ::libloading::Library::new(path)?; + Self::from_library(library) + } + pub unsafe fn from_library(library: L) -> Result + where + L: Into<::libloading::Library>, + { + let __library = library.into(); + let foo = __library.get(b"_Z3fooPv\0").map(|sym| *sym); + let baz = __library.get(b"_Z3bazPv\0").map(|sym| *sym); + let bazz = __library.get(b"_Z4bazziz\0").map(|sym| *sym); + Ok(TestLib { + __library, + foo, + baz, + bazz, + }) + } + pub unsafe fn foo(&self, x: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int { + (self.foo.as_ref().expect("Expected function, got error."))(x) + } + pub unsafe fn baz(&self, x: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int { + (self.baz.as_ref().expect("Expected function, got error."))(x) + } +} diff --git a/bindgen-tests/tests/expectations/tests/dynamic_loading_with_blocklist.rs b/bindgen-tests/tests/expectations/tests/dynamic_loading_with_blocklist.rs new file mode 100644 index 0000000000..8c86674f7a --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/dynamic_loading_with_blocklist.rs @@ -0,0 +1,75 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct X { + pub _x: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of X"][::std::mem::size_of::() - 4usize]; + ["Alignment of X"][::std::mem::align_of::() - 4usize]; + ["Offset of field: X::_x"][::std::mem::offset_of!(X, _x) - 0usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN1X13some_functionEv"] + pub fn X_some_function(this: *mut X); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN1X19some_other_functionEv"] + pub fn X_some_other_function(this: *mut X); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN1XC1Ei"] + pub fn X_X(this: *mut X, x: ::std::os::raw::c_int); +} +impl X { + #[inline] + pub unsafe fn some_function(&mut self) { + X_some_function(self) + } + #[inline] + pub unsafe fn some_other_function(&mut self) { + X_some_other_function(self) + } + #[inline] + pub unsafe fn new(x: ::std::os::raw::c_int) -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + X_X(__bindgen_tmp.as_mut_ptr(), x); + __bindgen_tmp.assume_init() + } +} +pub struct TestLib { + __library: ::libloading::Library, + pub foo: Result< + unsafe extern "C" fn(x: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + ::libloading::Error, + >, + pub bar: Result< + unsafe extern "C" fn(x: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + ::libloading::Error, + >, +} +impl TestLib { + pub unsafe fn new

(path: P) -> Result + where + P: AsRef<::std::ffi::OsStr>, + { + let library = ::libloading::Library::new(path)?; + Self::from_library(library) + } + pub unsafe fn from_library(library: L) -> Result + where + L: Into<::libloading::Library>, + { + let __library = library.into(); + let foo = __library.get(b"_Z3fooPv\0").map(|sym| *sym); + let bar = __library.get(b"_Z3barPv\0").map(|sym| *sym); + Ok(TestLib { __library, foo, bar }) + } + pub unsafe fn foo(&self, x: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int { + (self.foo.as_ref().expect("Expected function, got error."))(x) + } + pub unsafe fn bar(&self, x: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int { + (self.bar.as_ref().expect("Expected function, got error."))(x) + } +} diff --git a/bindgen-tests/tests/expectations/tests/dynamic_loading_with_class.rs b/bindgen-tests/tests/expectations/tests/dynamic_loading_with_class.rs new file mode 100644 index 0000000000..65ff2b2f72 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/dynamic_loading_with_class.rs @@ -0,0 +1,72 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct A { + pub _x: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A"][::std::mem::size_of::() - 4usize]; + ["Alignment of A"][::std::mem::align_of::() - 4usize]; + ["Offset of field: A::_x"][::std::mem::offset_of!(A, _x) - 0usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN1A13some_functionEv"] + pub fn A_some_function(this: *mut A); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN1A19some_other_functionEv"] + pub fn A_some_other_function(this: *mut A); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN1AC1Ei"] + pub fn A_A(this: *mut A, x: ::std::os::raw::c_int); +} +impl A { + #[inline] + pub unsafe fn some_function(&mut self) { + A_some_function(self) + } + #[inline] + pub unsafe fn some_other_function(&mut self) { + A_some_other_function(self) + } + #[inline] + pub unsafe fn new(x: ::std::os::raw::c_int) -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + A_A(__bindgen_tmp.as_mut_ptr(), x); + __bindgen_tmp.assume_init() + } +} +pub struct TestLib { + __library: ::libloading::Library, + pub foo: Result< + unsafe extern "C" fn(x: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + ::libloading::Error, + >, + pub bar: Result, +} +impl TestLib { + pub unsafe fn new

(path: P) -> Result + where + P: AsRef<::std::ffi::OsStr>, + { + let library = ::libloading::Library::new(path)?; + Self::from_library(library) + } + pub unsafe fn from_library(library: L) -> Result + where + L: Into<::libloading::Library>, + { + let __library = library.into(); + let foo = __library.get(b"_Z3fooPv\0").map(|sym| *sym); + let bar = __library.get(b"_Z3barv\0").map(|sym| *sym); + Ok(TestLib { __library, foo, bar }) + } + pub unsafe fn foo(&self, x: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int { + (self.foo.as_ref().expect("Expected function, got error."))(x) + } + pub unsafe fn bar(&self) { + (self.bar.as_ref().expect("Expected function, got error."))() + } +} diff --git a/bindgen-tests/tests/expectations/tests/elaborated.rs b/bindgen-tests/tests/expectations/tests/elaborated.rs new file mode 100644 index 0000000000..81c0733089 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/elaborated.rs @@ -0,0 +1,6 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type whatever_whatever_t = ::std::os::raw::c_int; +unsafe extern "C" { + #[link_name = "\u{1}_Z9somethingPKi"] + pub fn something(wat: *const whatever_whatever_t); +} diff --git a/bindgen-tests/tests/expectations/tests/empty-enum.rs b/bindgen-tests/tests/expectations/tests/empty-enum.rs new file mode 100644 index 0000000000..d19aa41845 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/empty-enum.rs @@ -0,0 +1,34 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type EmptyConstified = ::std::os::raw::c_uint; +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum EmptyRustified { + __bindgen_cannot_repr_c_on_empty_enum = 0, +} +pub mod EmptyModule { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_uint; +} +#[repr(i8)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum EmptyClassRustified { + __bindgen_cannot_repr_c_on_empty_enum = 0, +} +pub type EmptyClassConstified = ::std::os::raw::c_char; +pub mod EmptyClassModule { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_char; +} +#[repr(i8)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum ForwardClassRustified { + __bindgen_cannot_repr_c_on_empty_enum = 0, +} +pub type ForwardClassConstified = ::std::os::raw::c_char; +pub mod ForwardClassModule { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_char; +} diff --git a/bindgen-tests/tests/expectations/tests/empty-union.rs b/bindgen-tests/tests/expectations/tests/empty-union.rs new file mode 100644 index 0000000000..de0f806eb5 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/empty-union.rs @@ -0,0 +1,15 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone)] +pub union a__bindgen_ty_1 { + pub _address: u8, +} +impl Default for a__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/empty_template_param_name.rs b/bindgen-tests/tests/expectations/tests/empty_template_param_name.rs new file mode 100644 index 0000000000..db5764ab25 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/empty_template_param_name.rs @@ -0,0 +1,7 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type __void_t = ::std::os::raw::c_void; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct __iterator_traits { + pub _address: u8, +} diff --git a/bindgen-tests/tests/expectations/tests/enum-default-bitfield.rs b/bindgen-tests/tests/expectations/tests/enum-default-bitfield.rs new file mode 100644 index 0000000000..dda688617c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum-default-bitfield.rs @@ -0,0 +1,160 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct foo { + pub member: foo__bindgen_ty_1, +} +pub const foo_FOO_A: foo__bindgen_ty_1 = foo__bindgen_ty_1(0); +pub const foo_FOO_B: foo__bindgen_ty_1 = foo__bindgen_ty_1(1); +impl ::std::ops::BitOr for foo__bindgen_ty_1 { + type Output = Self; + #[inline] + fn bitor(self, other: Self) -> Self { + foo__bindgen_ty_1(self.0 | other.0) + } +} +impl ::std::ops::BitOrAssign for foo__bindgen_ty_1 { + #[inline] + fn bitor_assign(&mut self, rhs: foo__bindgen_ty_1) { + self.0 |= rhs.0; + } +} +impl ::std::ops::BitAnd for foo__bindgen_ty_1 { + type Output = Self; + #[inline] + fn bitand(self, other: Self) -> Self { + foo__bindgen_ty_1(self.0 & other.0) + } +} +impl ::std::ops::BitAndAssign for foo__bindgen_ty_1 { + #[inline] + fn bitand_assign(&mut self, rhs: foo__bindgen_ty_1) { + self.0 &= rhs.0; + } +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct foo__bindgen_ty_1(pub ::std::os::raw::c_uint); +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::member"][::std::mem::offset_of!(foo, member) - 0usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Foo { + pub const Bar: Foo = Foo(0); + pub const Qux: Foo = Foo(1); +} +impl ::std::ops::BitOr for Foo { + type Output = Self; + #[inline] + fn bitor(self, other: Self) -> Self { + Foo(self.0 | other.0) + } +} +impl ::std::ops::BitOrAssign for Foo { + #[inline] + fn bitor_assign(&mut self, rhs: Foo) { + self.0 |= rhs.0; + } +} +impl ::std::ops::BitAnd for Foo { + type Output = Self; + #[inline] + fn bitand(self, other: Self) -> Self { + Foo(self.0 & other.0) + } +} +impl ::std::ops::BitAndAssign for Foo { + #[inline] + fn bitand_assign(&mut self, rhs: Foo) { + self.0 &= rhs.0; + } +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Foo(pub ::std::os::raw::c_uint); +pub mod Neg { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_int; + pub const MinusOne: Type = -1; + pub const One: Type = 1; +} +impl NoDebug { + pub const NoDebug1: NoDebug = NoDebug(0); + pub const NoDebug2: NoDebug = NoDebug(1); +} +impl ::std::ops::BitOr for NoDebug { + type Output = Self; + #[inline] + fn bitor(self, other: Self) -> Self { + NoDebug(self.0 | other.0) + } +} +impl ::std::ops::BitOrAssign for NoDebug { + #[inline] + fn bitor_assign(&mut self, rhs: NoDebug) { + self.0 |= rhs.0; + } +} +impl ::std::ops::BitAnd for NoDebug { + type Output = Self; + #[inline] + fn bitand(self, other: Self) -> Self { + NoDebug(self.0 & other.0) + } +} +impl ::std::ops::BitAndAssign for NoDebug { + #[inline] + fn bitand_assign(&mut self, rhs: NoDebug) { + self.0 &= rhs.0; + } +} +#[repr(transparent)] +///

+#[derive(Copy, Clone, Hash, PartialEq, Eq)] +pub struct NoDebug(pub ::std::os::raw::c_uint); +impl Debug { + pub const Debug1: Debug = Debug(0); + pub const Debug2: Debug = Debug(1); +} +impl ::std::ops::BitOr for Debug { + type Output = Self; + #[inline] + fn bitor(self, other: Self) -> Self { + Debug(self.0 | other.0) + } +} +impl ::std::ops::BitOrAssign for Debug { + #[inline] + fn bitor_assign(&mut self, rhs: Debug) { + self.0 |= rhs.0; + } +} +impl ::std::ops::BitAnd for Debug { + type Output = Self; + #[inline] + fn bitand(self, other: Self) -> Self { + Debug(self.0 & other.0) + } +} +impl ::std::ops::BitAndAssign for Debug { + #[inline] + fn bitand_assign(&mut self, rhs: Debug) { + self.0 &= rhs.0; + } +} +#[repr(transparent)] +///
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Debug(pub ::std::os::raw::c_uint); diff --git a/bindgen-tests/tests/expectations/tests/enum-default-consts.rs b/bindgen-tests/tests/expectations/tests/enum-default-consts.rs new file mode 100644 index 0000000000..1432182310 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum-default-consts.rs @@ -0,0 +1,42 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct foo { + pub member: foo__bindgen_ty_1, +} +pub const foo_FOO_A: foo__bindgen_ty_1 = 0; +pub const foo_FOO_B: foo__bindgen_ty_1 = 1; +pub type foo__bindgen_ty_1 = ::std::os::raw::c_uint; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::member"][::std::mem::offset_of!(foo, member) - 0usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub const Foo_Bar: Foo = 0; +pub const Foo_Qux: Foo = 1; +pub type Foo = ::std::os::raw::c_uint; +pub mod Neg { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_int; + pub const MinusOne: Type = -1; + pub const One: Type = 1; +} +pub const NoDebug_NoDebug1: NoDebug = 0; +pub const NoDebug_NoDebug2: NoDebug = 1; +///
+pub type NoDebug = ::std::os::raw::c_uint; +pub const Debug_Debug1: Debug = 0; +pub const Debug_Debug2: Debug = 1; +///
+pub type Debug = ::std::os::raw::c_uint; diff --git a/bindgen-tests/tests/expectations/tests/enum-default-module.rs b/bindgen-tests/tests/expectations/tests/enum-default-module.rs new file mode 100644 index 0000000000..23fbd22c6e --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum-default-module.rs @@ -0,0 +1,58 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct foo { + pub member: foo__bindgen_ty_1::Type, +} +pub mod foo__bindgen_ty_1 { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_uint; + pub const FOO_A: Type = 0; + pub const FOO_B: Type = 1; +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::member"][::std::mem::offset_of!(foo, member) - 0usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub mod Foo { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_uint; + pub const Bar: Type = 0; + pub const Qux: Type = 1; +} +pub mod Neg { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_int; + pub const MinusOne: Type = -1; + pub const One: Type = 1; +} +pub mod NoDebug { + #[allow(unused_imports)] + use super::*; + ///
+ pub type Type = ::std::os::raw::c_uint; + pub const NoDebug1: Type = 0; + pub const NoDebug2: Type = 1; +} +pub mod Debug { + #[allow(unused_imports)] + use super::*; + ///
+ pub type Type = ::std::os::raw::c_uint; + pub const Debug1: Type = 0; + pub const Debug2: Type = 1; +} diff --git a/bindgen-tests/tests/expectations/tests/enum-default-rust.d b/bindgen-tests/tests/expectations/tests/enum-default-rust.d new file mode 100644 index 0000000000..a6540005c9 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum-default-rust.d @@ -0,0 +1 @@ +tests/expectations/tests/enum-default-rust.rs: tests/headers/enum-default-rust.h tests/headers/enum.h diff --git a/bindgen-tests/tests/expectations/tests/enum-default-rust.rs b/bindgen-tests/tests/expectations/tests/enum-default-rust.rs new file mode 100644 index 0000000000..59901a78ac --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum-default-rust.rs @@ -0,0 +1,56 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct foo { + pub member: foo__bindgen_ty_1, +} +pub const foo_FOO_A: foo__bindgen_ty_1 = foo__bindgen_ty_1::FOO_A; +pub const foo_FOO_B: foo__bindgen_ty_1 = foo__bindgen_ty_1::FOO_B; +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum foo__bindgen_ty_1 { + FOO_A = 0, + FOO_B = 1, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::member"][::std::mem::offset_of!(foo, member) - 0usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum Foo { + Bar = 0, + Qux = 1, +} +pub mod Neg { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_int; + pub const MinusOne: Type = -1; + pub const One: Type = 1; +} +#[repr(u32)] +///
+#[derive(Copy, Clone, Hash, PartialEq, Eq)] +pub enum NoDebug { + NoDebug1 = 0, + NoDebug2 = 1, +} +#[repr(u32)] +///
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum Debug { + Debug1 = 0, + Debug2 = 1, +} diff --git a/bindgen-tests/tests/expectations/tests/enum-doc-bitfield.rs b/bindgen-tests/tests/expectations/tests/enum-doc-bitfield.rs new file mode 100644 index 0000000000..33eec3e44f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum-doc-bitfield.rs @@ -0,0 +1,48 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +impl B { + /// Document field with three slashes + pub const VAR_A: B = B(0); + /// Document field with preceding star + pub const VAR_B: B = B(1); + /// Document field with preceding exclamation + pub const VAR_C: B = B(2); + ///< Document field with following star + pub const VAR_D: B = B(3); + ///< Document field with following exclamation + pub const VAR_E: B = B(4); + /** Document field with preceding star, with a loong long multiline + comment. + + Very interesting documentation, definitely.*/ + pub const VAR_F: B = B(5); +} +impl ::std::ops::BitOr for B { + type Output = Self; + #[inline] + fn bitor(self, other: Self) -> Self { + B(self.0 | other.0) + } +} +impl ::std::ops::BitOrAssign for B { + #[inline] + fn bitor_assign(&mut self, rhs: B) { + self.0 |= rhs.0; + } +} +impl ::std::ops::BitAnd for B { + type Output = Self; + #[inline] + fn bitand(self, other: Self) -> Self { + B(self.0 & other.0) + } +} +impl ::std::ops::BitAndAssign for B { + #[inline] + fn bitand_assign(&mut self, rhs: B) { + self.0 &= rhs.0; + } +} +#[repr(transparent)] +/// Document enum +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct B(pub ::std::os::raw::c_uint); diff --git a/bindgen-tests/tests/expectations/tests/enum-doc-mod.rs b/bindgen-tests/tests/expectations/tests/enum-doc-mod.rs new file mode 100644 index 0000000000..580d8165ac --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum-doc-mod.rs @@ -0,0 +1,22 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod B { + #[allow(unused_imports)] + use super::*; + /// Document enum + pub type Type = ::std::os::raw::c_uint; + /// Document field with three slashes + pub const VAR_A: Type = 0; + /// Document field with preceding star + pub const VAR_B: Type = 1; + /// Document field with preceding exclamation + pub const VAR_C: Type = 2; + ///< Document field with following star + pub const VAR_D: Type = 3; + ///< Document field with following exclamation + pub const VAR_E: Type = 4; + /** Document field with preceding star, with a loong long multiline + comment. + + Very interesting documentation, definitely.*/ + pub const VAR_F: Type = 5; +} diff --git a/bindgen-tests/tests/expectations/tests/enum-doc-rusty-non-exhaustive.rs b/bindgen-tests/tests/expectations/tests/enum-doc-rusty-non-exhaustive.rs new file mode 100644 index 0000000000..1d09466119 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum-doc-rusty-non-exhaustive.rs @@ -0,0 +1,22 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(u32)] +#[non_exhaustive] +/// Document enum +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum B { + /// Document field with three slashes + VAR_A = 0, + /// Document field with preceding star + VAR_B = 1, + /// Document field with preceding exclamation + VAR_C = 2, + ///< Document field with following star + VAR_D = 3, + ///< Document field with following exclamation + VAR_E = 4, + /** Document field with preceding star, with a loong long multiline + comment. + + Very interesting documentation, definitely.*/ + VAR_F = 5, +} diff --git a/bindgen-tests/tests/expectations/tests/enum-doc-rusty.rs b/bindgen-tests/tests/expectations/tests/enum-doc-rusty.rs new file mode 100644 index 0000000000..3eec0759c5 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum-doc-rusty.rs @@ -0,0 +1,21 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(u32)] +/// Document enum +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum B { + /// Document field with three slashes + VAR_A = 0, + /// Document field with preceding star + VAR_B = 1, + /// Document field with preceding exclamation + VAR_C = 2, + ///< Document field with following star + VAR_D = 3, + ///< Document field with following exclamation + VAR_E = 4, + /** Document field with preceding star, with a loong long multiline + comment. + + Very interesting documentation, definitely.*/ + VAR_F = 5, +} diff --git a/bindgen-tests/tests/expectations/tests/enum-doc.rs b/bindgen-tests/tests/expectations/tests/enum-doc.rs new file mode 100644 index 0000000000..98a7eed8f8 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum-doc.rs @@ -0,0 +1,18 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +/// Document field with three slashes +pub const B_VAR_A: B = 0; +/// Document field with preceding star +pub const B_VAR_B: B = 1; +/// Document field with preceding exclamation +pub const B_VAR_C: B = 2; +///< Document field with following star +pub const B_VAR_D: B = 3; +///< Document field with following exclamation +pub const B_VAR_E: B = 4; +/** Document field with preceding star, with a loong long multiline + comment. + + Very interesting documentation, definitely.*/ +pub const B_VAR_F: B = 5; +/// Document enum +pub type B = ::std::os::raw::c_uint; diff --git a/bindgen-tests/tests/expectations/tests/enum-no-debug-rust.rs b/bindgen-tests/tests/expectations/tests/enum-no-debug-rust.rs new file mode 100644 index 0000000000..643577e1e3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum-no-debug-rust.rs @@ -0,0 +1,56 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct foo { + pub member: foo__bindgen_ty_1, +} +pub const foo_FOO_A: foo__bindgen_ty_1 = foo__bindgen_ty_1::FOO_A; +pub const foo_FOO_B: foo__bindgen_ty_1 = foo__bindgen_ty_1::FOO_B; +#[repr(u32)] +#[derive(Copy, Clone, Hash, PartialEq, Eq)] +pub enum foo__bindgen_ty_1 { + FOO_A = 0, + FOO_B = 1, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::member"][::std::mem::offset_of!(foo, member) - 0usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(u32)] +#[derive(Copy, Clone, Hash, PartialEq, Eq)] +pub enum Foo { + Bar = 0, + Qux = 1, +} +pub mod Neg { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_int; + pub const MinusOne: Type = -1; + pub const One: Type = 1; +} +#[repr(u32)] +///
+#[derive(Copy, Clone, Hash, PartialEq, Eq)] +pub enum NoDebug { + NoDebug1 = 0, + NoDebug2 = 1, +} +#[repr(u32)] +///
+#[derive(Copy, Clone, Hash, PartialEq, Eq, Debug)] +pub enum Debug { + Debug1 = 0, + Debug2 = 1, +} diff --git a/bindgen-tests/tests/expectations/tests/enum-translate-type.rs b/bindgen-tests/tests/expectations/tests/enum-translate-type.rs new file mode 100644 index 0000000000..2431e48d5b --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum-translate-type.rs @@ -0,0 +1,9 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const my_enum1_A: my_enum1 = 0; +pub type my_enum1 = u32; +pub const my_enum2_B: my_enum2 = -1; +pub type my_enum2 = i32; +pub const my_enum3_C: my_enum3 = 0; +pub type my_enum3 = i16; +pub const my_enum4_D: my_enum4 = 255; +pub type my_enum4 = u8; diff --git a/bindgen-tests/tests/expectations/tests/enum-typedef.rs b/bindgen-tests/tests/expectations/tests/enum-typedef.rs new file mode 100644 index 0000000000..772184b39f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum-typedef.rs @@ -0,0 +1,5 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const Enum_Variant: Enum = 0; +pub type Enum = i16; +pub type TypedefFirst = i16; +pub const TypedefFirst_Variant2: TypedefFirst = 0; diff --git a/bindgen-tests/tests/expectations/tests/enum-undefault.rs b/bindgen-tests/tests/expectations/tests/enum-undefault.rs new file mode 100644 index 0000000000..01a7aa3cea --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum-undefault.rs @@ -0,0 +1,10 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum Foo { + Bar = 0, + Qux = 1, +} +pub const Neg_MinusOne: Neg = -1; +pub const Neg_One: Neg = 1; +pub type Neg = ::std::os::raw::c_int; diff --git a/bindgen-tests/tests/expectations/tests/enum-variant-replaces.rs b/bindgen-tests/tests/expectations/tests/enum-variant-replaces.rs new file mode 100644 index 0000000000..a661ca833b --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum-variant-replaces.rs @@ -0,0 +1,11 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +/**
+ + Should see PASS below.*/ +pub const OGRErr_PASS: OGRErr = 0; +/**
+ + Should see OGRERR_NONE instead of CUSTOM_OGRERR_NONE below.*/ +pub const OGRErr_OGRERR_NONE: OGRErr = 1; +///
+pub type OGRErr = ::std::os::raw::c_uint; diff --git a/bindgen-tests/tests/expectations/tests/enum.rs b/bindgen-tests/tests/expectations/tests/enum.rs new file mode 100644 index 0000000000..820182125a --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum.rs @@ -0,0 +1,38 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct foo { + pub member: foo__bindgen_ty_1, +} +pub const foo_FOO_A: foo__bindgen_ty_1 = 0; +pub const foo_FOO_B: foo__bindgen_ty_1 = 1; +pub type foo__bindgen_ty_1 = ::std::os::raw::c_uint; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::member"][::std::mem::offset_of!(foo, member) - 0usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub const Foo_Bar: Foo = 0; +pub const Foo_Qux: Foo = 1; +pub type Foo = ::std::os::raw::c_uint; +pub const Neg_MinusOne: Neg = -1; +pub const Neg_One: Neg = 1; +pub type Neg = ::std::os::raw::c_int; +pub const NoDebug_NoDebug1: NoDebug = 0; +pub const NoDebug_NoDebug2: NoDebug = 1; +///
+pub type NoDebug = ::std::os::raw::c_uint; +pub const Debug_Debug1: Debug = 0; +pub const Debug_Debug2: Debug = 1; +///
+pub type Debug = ::std::os::raw::c_uint; diff --git a/bindgen-tests/tests/expectations/tests/enum_alias.rs b/bindgen-tests/tests/expectations/tests/enum_alias.rs new file mode 100644 index 0000000000..0d29768837 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum_alias.rs @@ -0,0 +1,6 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(u8)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum Bar { + VAL = 0, +} diff --git a/bindgen-tests/tests/expectations/tests/enum_and_vtable_mangling.rs b/bindgen-tests/tests/expectations/tests/enum_and_vtable_mangling.rs new file mode 100644 index 0000000000..0a7e16d6dd --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum_and_vtable_mangling.rs @@ -0,0 +1,38 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const match_: _bindgen_ty_1 = _bindgen_ty_1::match_; +pub const whatever_else: _bindgen_ty_1 = _bindgen_ty_1::whatever_else; +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _bindgen_ty_1 { + match_ = 0, + whatever_else = 1, +} +#[repr(C)] +pub struct C__bindgen_vtable { + pub C_match: unsafe extern "C" fn(this: *mut C), +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct C { + pub vtable_: *const C__bindgen_vtable, + pub i: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C"][::std::mem::size_of::() - 16usize]; + ["Alignment of C"][::std::mem::align_of::() - 8usize]; + ["Offset of field: C::i"][::std::mem::offset_of!(C, i) - 8usize]; +}; +impl Default for C { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN1C5matchEv"] + pub fn C_match(this: *mut ::std::os::raw::c_void); +} diff --git a/bindgen-tests/tests/expectations/tests/enum_dupe.rs b/bindgen-tests/tests/expectations/tests/enum_dupe.rs new file mode 100644 index 0000000000..3ee4c68cbd --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum_dupe.rs @@ -0,0 +1,9 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +impl Foo { + pub const Dupe: Foo = Foo::Bar; +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum Foo { + Bar = 1, +} diff --git a/bindgen-tests/tests/expectations/tests/enum_explicit_type.rs b/bindgen-tests/tests/expectations/tests/enum_explicit_type.rs new file mode 100644 index 0000000000..1f3dd36f96 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum_explicit_type.rs @@ -0,0 +1,53 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(u8)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum Foo { + Bar = 0, + Qux = 1, +} +#[repr(i8)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum Neg { + MinusOne = -1, + One = 1, +} +#[repr(u16)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum Bigger { + Much = 255, + Larger = 256, +} +#[repr(i64)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum MuchLong { + MuchLow = -4294967296, +} +#[repr(i64)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum MuchLongLong { + I64_MIN = -9223372036854775808, +} +#[repr(u64)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum MuchULongLong { + MuchHigh = 4294967296, +} +#[repr(u8)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum BoolEnumsAreFun { + Value = 1, +} +pub type MyType = bool; +#[repr(u8)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum BoolEnumsAreFun2 { + Value2 = 1, +} +pub const AnonymousVariantOne: _bindgen_ty_1 = _bindgen_ty_1::AnonymousVariantOne; +pub const AnonymousVariantTwo: _bindgen_ty_1 = _bindgen_ty_1::AnonymousVariantTwo; +#[repr(u8)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _bindgen_ty_1 { + AnonymousVariantOne = 0, + AnonymousVariantTwo = 1, +} diff --git a/bindgen-tests/tests/expectations/tests/enum_explicit_type_constants.rs b/bindgen-tests/tests/expectations/tests/enum_explicit_type_constants.rs new file mode 100644 index 0000000000..8f310572b6 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum_explicit_type_constants.rs @@ -0,0 +1,25 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(not(target_os = "windows"))] +pub const Foo_Bar: Foo = 0; +pub const Foo_Qux: Foo = 1; +pub type Foo = ::std::os::raw::c_uchar; +pub const Neg_MinusOne: Neg = -1; +pub const Neg_One: Neg = 1; +pub type Neg = ::std::os::raw::c_schar; +pub const Bigger_Much: Bigger = 255; +pub const Bigger_Larger: Bigger = 256; +pub type Bigger = ::std::os::raw::c_ushort; +pub const MuchLong_MuchLow: MuchLong = -4294967296; +pub type MuchLong = ::std::os::raw::c_long; +pub const MuchLongLong_I64_MIN: MuchLongLong = -9223372036854775808; +pub type MuchLongLong = ::std::os::raw::c_longlong; +pub const MuchULongLong_MuchHigh: MuchULongLong = 4294967296; +pub type MuchULongLong = ::std::os::raw::c_ulonglong; +pub const BoolEnumsAreFun_Value: BoolEnumsAreFun = true; +pub type BoolEnumsAreFun = bool; +pub type MyType = bool; +pub const BoolEnumsAreFun2_Value2: BoolEnumsAreFun2 = true; +pub type BoolEnumsAreFun2 = MyType; +pub const AnonymousVariantOne: _bindgen_ty_1 = 0; +pub const AnonymousVariantTwo: _bindgen_ty_1 = 1; +pub type _bindgen_ty_1 = ::std::os::raw::c_uchar; diff --git a/bindgen-tests/tests/expectations/tests/enum_in_template.rs b/bindgen-tests/tests/expectations/tests/enum_in_template.rs new file mode 100644 index 0000000000..e54a97b5f4 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum_in_template.rs @@ -0,0 +1,9 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +pub const Foo_Bar_A: Foo_Bar = 0; +pub const Foo_Bar_B: Foo_Bar = 0; +pub type Foo_Bar = i32; diff --git a/bindgen-tests/tests/expectations/tests/enum_in_template_with_typedef.rs b/bindgen-tests/tests/expectations/tests/enum_in_template_with_typedef.rs new file mode 100644 index 0000000000..b71923e10f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum_in_template_with_typedef.rs @@ -0,0 +1,15 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct std_fbstring_core { + pub _address: u8, +} +pub type std_fbstring_core_category_type = u8; +impl std_fbstring_core_Category { + pub const Bar: std_fbstring_core_Category = std_fbstring_core_Category::Foo; +} +#[repr(u8)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum std_fbstring_core_Category { + Foo = 0, +} diff --git a/bindgen-tests/tests/expectations/tests/enum_negative.rs b/bindgen-tests/tests/expectations/tests/enum_negative.rs new file mode 100644 index 0000000000..f946e0f044 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum_negative.rs @@ -0,0 +1,7 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum Foo { + Bar = -2, + Qux = 1, +} diff --git a/bindgen-tests/tests/expectations/tests/enum_packed.rs b/bindgen-tests/tests/expectations/tests/enum_packed.rs new file mode 100644 index 0000000000..d4ec2192d1 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/enum_packed.rs @@ -0,0 +1,19 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(u8)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum Foo { + Bar = 0, + Qux = 1, +} +#[repr(i8)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum Neg { + MinusOne = -1, + One = 1, +} +#[repr(u16)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum Bigger { + Much = 255, + Larger = 256, +} diff --git a/bindgen-tests/tests/expectations/tests/error-E0600-cannot-apply-unary-negation-to-u32.rs b/bindgen-tests/tests/expectations/tests/error-E0600-cannot-apply-unary-negation-to-u32.rs new file mode 100644 index 0000000000..79004238fc --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/error-E0600-cannot-apply-unary-negation-to-u32.rs @@ -0,0 +1,3 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![allow(overflowing_literals)] +pub const a: u32 = 4294967291; diff --git a/bindgen-tests/tests/expectations/tests/eval-value-dependent.rs b/bindgen-tests/tests/expectations/tests/eval-value-dependent.rs new file mode 100644 index 0000000000..b9b2709cfa --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/eval-value-dependent.rs @@ -0,0 +1,7 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct e { + pub _address: u8, +} +pub type e_f = d; diff --git a/bindgen-tests/tests/expectations/tests/eval-variadic-template-parameter.rs b/bindgen-tests/tests/expectations/tests/eval-variadic-template-parameter.rs new file mode 100644 index 0000000000..fccd2ad5d7 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/eval-variadic-template-parameter.rs @@ -0,0 +1,6 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct B { + pub _address: u8, +} diff --git a/bindgen-tests/tests/expectations/tests/explicit-padding.rs b/bindgen-tests/tests/expectations/tests/explicit-padding.rs new file mode 100644 index 0000000000..ec21399106 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/explicit-padding.rs @@ -0,0 +1,48 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct pad_me { + pub first: u8, + pub __bindgen_padding_0: [u8; 3usize], + pub second: u32, + pub third: u16, + pub __bindgen_padding_1: [u8; 2usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of pad_me"][::std::mem::size_of::() - 12usize]; + ["Alignment of pad_me"][::std::mem::align_of::() - 4usize]; + ["Offset of field: pad_me::first"][::std::mem::offset_of!(pad_me, first) - 0usize]; + ["Offset of field: pad_me::second"][::std::mem::offset_of!(pad_me, second) - 4usize]; + ["Offset of field: pad_me::third"][::std::mem::offset_of!(pad_me, third) - 8usize]; +}; +#[repr(C)] +#[derive(Copy, Clone)] +pub union dont_pad_me { + pub first: u8, + pub second: u32, + pub third: u16, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of dont_pad_me"][::std::mem::size_of::() - 4usize]; + ["Alignment of dont_pad_me"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: dont_pad_me::first", + ][::std::mem::offset_of!(dont_pad_me, first) - 0usize]; + [ + "Offset of field: dont_pad_me::second", + ][::std::mem::offset_of!(dont_pad_me, second) - 0usize]; + [ + "Offset of field: dont_pad_me::third", + ][::std::mem::offset_of!(dont_pad_me, third) - 0usize]; +}; +impl Default for dont_pad_me { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/extern-const-struct.rs b/bindgen-tests/tests/expectations/tests/extern-const-struct.rs new file mode 100644 index 0000000000..7085bef5c8 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/extern-const-struct.rs @@ -0,0 +1,24 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nsFoo { + pub details: [f32; 400usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of nsFoo"][::std::mem::size_of::() - 1600usize]; + ["Alignment of nsFoo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: nsFoo::details"][::std::mem::offset_of!(nsFoo, details) - 0usize]; +}; +impl Default for nsFoo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +unsafe extern "C" { + pub static gDetails: nsFoo; +} diff --git a/bindgen-tests/tests/expectations/tests/extern-fn-block-attrs-many.rs b/bindgen-tests/tests/expectations/tests/extern-fn-block-attrs-many.rs new file mode 100644 index 0000000000..5aa9e45ec2 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/extern-fn-block-attrs-many.rs @@ -0,0 +1,6 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(dead_code)] +#[cfg_attr(not(windows), link(wasm_import_module = "test-module"))] +unsafe extern "C" { + pub fn test_function(); +} diff --git a/bindgen-tests/tests/expectations/tests/extern-fn-block-attrs-wasm.rs b/bindgen-tests/tests/expectations/tests/extern-fn-block-attrs-wasm.rs new file mode 100644 index 0000000000..388594b27e --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/extern-fn-block-attrs-wasm.rs @@ -0,0 +1,6 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[link(wasm_import_module = "test-module")] +#[allow(dead_code)] +unsafe extern "C" { + pub fn test_function(); +} diff --git a/bindgen-tests/tests/expectations/tests/extern-fn-block-attrs.rs b/bindgen-tests/tests/expectations/tests/extern-fn-block-attrs.rs new file mode 100644 index 0000000000..657cec106a --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/extern-fn-block-attrs.rs @@ -0,0 +1,5 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(dead_code)] +unsafe extern "C" { + pub fn test_function(); +} diff --git a/bindgen-tests/tests/expectations/tests/extern.rs b/bindgen-tests/tests/expectations/tests/extern.rs new file mode 100644 index 0000000000..496f595a0d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/extern.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type foo = ::std::option::Option< + unsafe extern "C" fn(bar: ::std::os::raw::c_int) -> ::std::os::raw::c_int, +>; diff --git a/bindgen-tests/tests/expectations/tests/extern_blocks_post_1_82.rs b/bindgen-tests/tests/expectations/tests/extern_blocks_post_1_82.rs new file mode 100644 index 0000000000..a322df78ce --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/extern_blocks_post_1_82.rs @@ -0,0 +1,7 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn cool_function(i: ::std::os::raw::c_int, c: ::std::os::raw::c_char); +} +unsafe extern "C" { + pub static mut cool_static: ::std::os::raw::c_int; +} diff --git a/bindgen-tests/tests/expectations/tests/extern_blocks_pre_1_82.rs b/bindgen-tests/tests/expectations/tests/extern_blocks_pre_1_82.rs new file mode 100644 index 0000000000..a322df78ce --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/extern_blocks_pre_1_82.rs @@ -0,0 +1,7 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn cool_function(i: ::std::os::raw::c_int, c: ::std::os::raw::c_char); +} +unsafe extern "C" { + pub static mut cool_static: ::std::os::raw::c_int; +} diff --git a/bindgen-tests/tests/expectations/tests/field-visibility-callback.rs b/bindgen-tests/tests/expectations/tests/field-visibility-callback.rs new file mode 100644 index 0000000000..99ca3d4b9b --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/field-visibility-callback.rs @@ -0,0 +1,264 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct my_struct { + pub a: ::std::os::raw::c_int, + private_b: ::std::os::raw::c_int, + _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + __bindgen_padding_0: [u8; 3usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of my_struct"][::std::mem::size_of::() - 12usize]; + ["Alignment of my_struct"][::std::mem::align_of::() - 4usize]; + ["Offset of field: my_struct::a"][::std::mem::offset_of!(my_struct, a) - 0usize]; + [ + "Offset of field: my_struct::private_b", + ][::std::mem::offset_of!(my_struct, private_b) - 4usize]; +}; +impl my_struct { + #[inline] + pub fn c(&self) -> ::std::os::raw::c_int { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_c(&mut self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn c_raw(this: *const Self) -> ::std::os::raw::c_int { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_c_raw(this: *mut Self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + fn private_d(&self) -> ::std::os::raw::c_int { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + fn set_private_d(&mut self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + unsafe fn private_d_raw(this: *const Self) -> ::std::os::raw::c_int { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) + as u32, + ) + } + } + #[inline] + unsafe fn set_private_d_raw(this: *mut Self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + fn new_bitfield_1( + c: ::std::os::raw::c_int, + private_d: ::std::os::raw::c_int, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let c: u32 = unsafe { ::std::mem::transmute(c) }; + c as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 1u8, + { + let private_d: u32 = unsafe { ::std::mem::transmute(private_d) }; + private_d as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/field-visibility.rs b/bindgen-tests/tests/expectations/tests/field-visibility.rs new file mode 100644 index 0000000000..13a1d9a543 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/field-visibility.rs @@ -0,0 +1,277 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct my_struct1 { + pub _bindgen_align: [u32; 0], + _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + __bindgen_padding_0: [u8; 3usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of my_struct1"][::std::mem::size_of::() - 4usize]; + ["Alignment of my_struct1"][::std::mem::align_of::() - 4usize]; +}; +impl my_struct1 { + #[inline] + fn a(&self) -> ::std::os::raw::c_int { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + fn set_a(&mut self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + unsafe fn a_raw(this: *const Self) -> ::std::os::raw::c_int { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) + as u32, + ) + } + } + #[inline] + unsafe fn set_a_raw(this: *mut Self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + fn new_bitfield_1(a: ::std::os::raw::c_int) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let a: u32 = unsafe { ::std::mem::transmute(a) }; + a as u64 + }, + ); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct my_struct2 { + pub _bindgen_align: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of my_struct2"][::std::mem::size_of::() - 4usize]; + ["Alignment of my_struct2"][::std::mem::align_of::() - 4usize]; +}; +impl my_struct2 { + #[inline] + pub fn a(&self) -> ::std::os::raw::c_int { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_a(&mut self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn a_raw(this: *const Self) -> ::std::os::raw::c_int { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_a_raw(this: *mut Self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + a: ::std::os::raw::c_int, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let a: u32 = unsafe { ::std::mem::transmute(a) }; + a as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/fit-macro-constant-types-signed.rs b/bindgen-tests/tests/expectations/tests/fit-macro-constant-types-signed.rs new file mode 100644 index 0000000000..d4ad5e0fcc --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/fit-macro-constant-types-signed.rs @@ -0,0 +1,48 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const N0: i8 = 0; +pub const N1: i8 = 1; +pub const N2: i8 = 2; +pub const N_1: i8 = -1; +pub const N_2: i8 = -2; +pub const MAX_U16: i32 = 65535; +pub const MAX_I16: i16 = 32767; +pub const MAX_I16_Plus1: i32 = 32768; +pub const MAX_U16_Plus1: i32 = 65536; +pub const MAX_I16_Minus1: i16 = 32766; +pub const MAX_U16_Minus1: i32 = 65534; +pub const MIN_U16: i8 = 0; +pub const MIN_I16: i16 = -32768; +pub const MIN_U16_Plus1: i8 = 1; +pub const MIN_I16_Plus1: i16 = -32767; +pub const MIN_U16_Minus1: i8 = -1; +pub const MIN_I16_Minus1: i32 = -32769; +pub const MAX_U32: i64 = 4294967295; +pub const MAX_I32: i32 = 2147483647; +pub const MAX_I32_Plus1: i64 = 2147483648; +pub const MAX_U32_Plus1: i64 = 4294967296; +pub const MAX_I32_Minus1: i32 = 2147483646; +pub const MAX_U32_Minus1: i64 = 4294967294; +pub const MIN_U32: i8 = 0; +pub const MIN_I32: i32 = -2147483648; +pub const MIN_U32_Plus1: i8 = 1; +pub const MIN_I32_Plus1: i32 = -2147483647; +pub const MIN_U32_Minus1: i8 = -1; +pub const MIN_I32_Minus1: i64 = -2147483649; +pub const LONG12: i64 = 123456789012; +pub const LONG_12: i64 = -123456789012; +unsafe extern "C" { + pub fn foo( + arg1: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_uint, + arg4: ::std::os::raw::c_char, + arg5: ::std::os::raw::c_uchar, + arg6: ::std::os::raw::c_schar, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bar( + arg1: ::std::os::raw::c_long, + arg2: ::std::os::raw::c_longlong, + ) -> ::std::os::raw::c_long; +} diff --git a/bindgen-tests/tests/expectations/tests/fit-macro-constant-types.rs b/bindgen-tests/tests/expectations/tests/fit-macro-constant-types.rs new file mode 100644 index 0000000000..5542a645da --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/fit-macro-constant-types.rs @@ -0,0 +1,48 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const N0: u8 = 0; +pub const N1: u8 = 1; +pub const N2: u8 = 2; +pub const N_1: i8 = -1; +pub const N_2: i8 = -2; +pub const MAX_U16: u16 = 65535; +pub const MAX_I16: u16 = 32767; +pub const MAX_I16_Plus1: u16 = 32768; +pub const MAX_U16_Plus1: u32 = 65536; +pub const MAX_I16_Minus1: u16 = 32766; +pub const MAX_U16_Minus1: u16 = 65534; +pub const MIN_U16: u8 = 0; +pub const MIN_I16: i16 = -32768; +pub const MIN_U16_Plus1: u8 = 1; +pub const MIN_I16_Plus1: i16 = -32767; +pub const MIN_U16_Minus1: i8 = -1; +pub const MIN_I16_Minus1: i32 = -32769; +pub const MAX_U32: u32 = 4294967295; +pub const MAX_I32: u32 = 2147483647; +pub const MAX_I32_Plus1: u32 = 2147483648; +pub const MAX_U32_Plus1: u64 = 4294967296; +pub const MAX_I32_Minus1: u32 = 2147483646; +pub const MAX_U32_Minus1: u32 = 4294967294; +pub const MIN_U32: u8 = 0; +pub const MIN_I32: i32 = -2147483648; +pub const MIN_U32_Plus1: u8 = 1; +pub const MIN_I32_Plus1: i32 = -2147483647; +pub const MIN_U32_Minus1: i8 = -1; +pub const MIN_I32_Minus1: i64 = -2147483649; +pub const LONG12: u64 = 123456789012; +pub const LONG_12: i64 = -123456789012; +unsafe extern "C" { + pub fn foo( + arg1: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_uint, + arg4: ::std::os::raw::c_char, + arg5: ::std::os::raw::c_uchar, + arg6: ::std::os::raw::c_schar, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bar( + arg1: ::std::os::raw::c_long, + arg2: ::std::os::raw::c_longlong, + ) -> ::std::os::raw::c_long; +} diff --git a/bindgen-tests/tests/expectations/tests/flexarray.rs b/bindgen-tests/tests/expectations/tests/flexarray.rs new file mode 100644 index 0000000000..b9c800366e --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/flexarray.rs @@ -0,0 +1,555 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(feature = "nightly")] +#![feature(ptr_metadata, layout_for_ptr)] +#[repr(C)] +#[derive(Default)] +pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); +impl __IncompleteArrayField { + #[inline] + pub const fn new() -> Self { + __IncompleteArrayField(::std::marker::PhantomData, []) + } + #[inline] + pub fn as_ptr(&self) -> *const T { + self as *const _ as *const T + } + #[inline] + pub fn as_mut_ptr(&mut self) -> *mut T { + self as *mut _ as *mut T + } + #[inline] + pub unsafe fn as_slice(&self, len: usize) -> &[T] { + ::std::slice::from_raw_parts(self.as_ptr(), len) + } + #[inline] + pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { + ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) + } +} +impl ::std::fmt::Debug for __IncompleteArrayField { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + fmt.write_str("__IncompleteArrayField") + } +} +#[repr(C)] +#[derive(Debug, Default)] +pub struct flexarray { + pub count: ::std::os::raw::c_int, + pub data: FAM, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of flexarray"][::std::mem::size_of::() - 4usize]; + ["Alignment of flexarray"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: flexarray::count", + ][::std::mem::offset_of!(flexarray, count) - 0usize]; + [ + "Offset of field: flexarray::data", + ][::std::mem::offset_of!(flexarray, data) - 4usize]; +}; +impl flexarray<[::std::os::raw::c_int]> { + pub fn layout(len: usize) -> ::std::alloc::Layout { + unsafe { + let p: *const Self = ::std::ptr::from_raw_parts( + ::std::ptr::null::<()>(), + len, + ); + ::std::alloc::Layout::for_value_raw(p) + } + } + #[inline] + pub fn fixed(&self) -> (&flexarray<[::std::os::raw::c_int; 0]>, usize) { + unsafe { + let (ptr, len) = (self as *const Self).to_raw_parts(); + (&*(ptr as *const flexarray<[::std::os::raw::c_int; 0]>), len) + } + } + #[inline] + pub fn fixed_mut(&mut self) -> (&mut flexarray<[::std::os::raw::c_int; 0]>, usize) { + unsafe { + let (ptr, len) = (self as *mut Self).to_raw_parts(); + (&mut *(ptr as *mut flexarray<[::std::os::raw::c_int; 0]>), len) + } + } +} +impl flexarray<[::std::os::raw::c_int; 0]> { + /// Convert a sized prefix to an unsized structure with the given length. + /// + /// SAFETY: Underlying storage is initialized up to at least `len` elements. + pub unsafe fn flex_ref(&self, len: usize) -> &flexarray<[::std::os::raw::c_int]> { + Self::flex_ptr(self, len) + } + /// Convert a mutable sized prefix to an unsized structure with the given length. + /// + /// SAFETY: Underlying storage is initialized up to at least `len` elements. + #[inline] + pub unsafe fn flex_ref_mut( + &mut self, + len: usize, + ) -> &mut flexarray<[::std::os::raw::c_int]> { + Self::flex_ptr_mut(self, len).assume_init() + } + /// Construct DST variant from a pointer and a size. + /// + /// NOTE: lifetime of returned reference is not tied to any underlying storage. + /// SAFETY: `ptr` is valid. Underlying storage is fully initialized up to at least `len` elements. + #[inline] + pub unsafe fn flex_ptr<'unbounded>( + ptr: *const Self, + len: usize, + ) -> &'unbounded flexarray<[::std::os::raw::c_int]> { + &*::std::ptr::from_raw_parts(ptr as *const (), len) + } + /// Construct mutable DST variant from a pointer and a + /// size. The returned `&mut` reference is initialized + /// pointing to memory referenced by `ptr`, but there's + /// no requirement that that memory be initialized. + /// + /// NOTE: lifetime of returned reference is not tied to any underlying storage. + /// SAFETY: `ptr` is valid. Underlying storage has space for at least `len` elements. + #[inline] + pub unsafe fn flex_ptr_mut<'unbounded>( + ptr: *mut Self, + len: usize, + ) -> ::std::mem::MaybeUninit<&'unbounded mut flexarray<[::std::os::raw::c_int]>> { + let mut uninit = ::std::mem::MaybeUninit::< + &mut flexarray<[::std::os::raw::c_int]>, + >::uninit(); + (uninit.as_mut_ptr() as *mut *mut flexarray<[::std::os::raw::c_int]>) + .write(::std::ptr::from_raw_parts_mut(ptr as *mut (), len)); + uninit + } +} +#[repr(C)] +#[derive(Debug, Default)] +pub struct flexarray_zero { + pub count: ::std::os::raw::c_int, + pub data: FAM, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of flexarray_zero"][::std::mem::size_of::() - 4usize]; + ["Alignment of flexarray_zero"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: flexarray_zero::count", + ][::std::mem::offset_of!(flexarray_zero, count) - 0usize]; + [ + "Offset of field: flexarray_zero::data", + ][::std::mem::offset_of!(flexarray_zero, data) - 4usize]; +}; +impl flexarray_zero<[::std::os::raw::c_int]> { + pub fn layout(len: usize) -> ::std::alloc::Layout { + unsafe { + let p: *const Self = ::std::ptr::from_raw_parts( + ::std::ptr::null::<()>(), + len, + ); + ::std::alloc::Layout::for_value_raw(p) + } + } + #[inline] + pub fn fixed(&self) -> (&flexarray_zero<[::std::os::raw::c_int; 0]>, usize) { + unsafe { + let (ptr, len) = (self as *const Self).to_raw_parts(); + (&*(ptr as *const flexarray_zero<[::std::os::raw::c_int; 0]>), len) + } + } + #[inline] + pub fn fixed_mut( + &mut self, + ) -> (&mut flexarray_zero<[::std::os::raw::c_int; 0]>, usize) { + unsafe { + let (ptr, len) = (self as *mut Self).to_raw_parts(); + (&mut *(ptr as *mut flexarray_zero<[::std::os::raw::c_int; 0]>), len) + } + } +} +impl flexarray_zero<[::std::os::raw::c_int; 0]> { + /// Convert a sized prefix to an unsized structure with the given length. + /// + /// SAFETY: Underlying storage is initialized up to at least `len` elements. + pub unsafe fn flex_ref( + &self, + len: usize, + ) -> &flexarray_zero<[::std::os::raw::c_int]> { + Self::flex_ptr(self, len) + } + /// Convert a mutable sized prefix to an unsized structure with the given length. + /// + /// SAFETY: Underlying storage is initialized up to at least `len` elements. + #[inline] + pub unsafe fn flex_ref_mut( + &mut self, + len: usize, + ) -> &mut flexarray_zero<[::std::os::raw::c_int]> { + Self::flex_ptr_mut(self, len).assume_init() + } + /// Construct DST variant from a pointer and a size. + /// + /// NOTE: lifetime of returned reference is not tied to any underlying storage. + /// SAFETY: `ptr` is valid. Underlying storage is fully initialized up to at least `len` elements. + #[inline] + pub unsafe fn flex_ptr<'unbounded>( + ptr: *const Self, + len: usize, + ) -> &'unbounded flexarray_zero<[::std::os::raw::c_int]> { + &*::std::ptr::from_raw_parts(ptr as *const (), len) + } + /// Construct mutable DST variant from a pointer and a + /// size. The returned `&mut` reference is initialized + /// pointing to memory referenced by `ptr`, but there's + /// no requirement that that memory be initialized. + /// + /// NOTE: lifetime of returned reference is not tied to any underlying storage. + /// SAFETY: `ptr` is valid. Underlying storage has space for at least `len` elements. + #[inline] + pub unsafe fn flex_ptr_mut<'unbounded>( + ptr: *mut Self, + len: usize, + ) -> ::std::mem::MaybeUninit< + &'unbounded mut flexarray_zero<[::std::os::raw::c_int]>, + > { + let mut uninit = ::std::mem::MaybeUninit::< + &mut flexarray_zero<[::std::os::raw::c_int]>, + >::uninit(); + (uninit.as_mut_ptr() as *mut *mut flexarray_zero<[::std::os::raw::c_int]>) + .write(::std::ptr::from_raw_parts_mut(ptr as *mut (), len)); + uninit + } +} +#[repr(C)] +#[derive(Debug)] +pub struct flexarray_template { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub count: ::std::os::raw::c_int, + pub data: FAM, +} +impl flexarray_template { + pub fn layout(len: usize) -> ::std::alloc::Layout { + unsafe { + let p: *const Self = ::std::ptr::from_raw_parts( + ::std::ptr::null::<()>(), + len, + ); + ::std::alloc::Layout::for_value_raw(p) + } + } + #[inline] + pub fn fixed(&self) -> (&flexarray_template, usize) { + unsafe { + let (ptr, len) = (self as *const Self).to_raw_parts(); + (&*(ptr as *const flexarray_template), len) + } + } + #[inline] + pub fn fixed_mut(&mut self) -> (&mut flexarray_template, usize) { + unsafe { + let (ptr, len) = (self as *mut Self).to_raw_parts(); + (&mut *(ptr as *mut flexarray_template), len) + } + } +} +impl flexarray_template { + /// Convert a sized prefix to an unsized structure with the given length. + /// + /// SAFETY: Underlying storage is initialized up to at least `len` elements. + pub unsafe fn flex_ref(&self, len: usize) -> &flexarray_template { + Self::flex_ptr(self, len) + } + /// Convert a mutable sized prefix to an unsized structure with the given length. + /// + /// SAFETY: Underlying storage is initialized up to at least `len` elements. + #[inline] + pub unsafe fn flex_ref_mut( + &mut self, + len: usize, + ) -> &mut flexarray_template { + Self::flex_ptr_mut(self, len).assume_init() + } + /// Construct DST variant from a pointer and a size. + /// + /// NOTE: lifetime of returned reference is not tied to any underlying storage. + /// SAFETY: `ptr` is valid. Underlying storage is fully initialized up to at least `len` elements. + #[inline] + pub unsafe fn flex_ptr<'unbounded>( + ptr: *const Self, + len: usize, + ) -> &'unbounded flexarray_template { + &*::std::ptr::from_raw_parts(ptr as *const (), len) + } + /// Construct mutable DST variant from a pointer and a + /// size. The returned `&mut` reference is initialized + /// pointing to memory referenced by `ptr`, but there's + /// no requirement that that memory be initialized. + /// + /// NOTE: lifetime of returned reference is not tied to any underlying storage. + /// SAFETY: `ptr` is valid. Underlying storage has space for at least `len` elements. + #[inline] + pub unsafe fn flex_ptr_mut<'unbounded>( + ptr: *mut Self, + len: usize, + ) -> ::std::mem::MaybeUninit<&'unbounded mut flexarray_template> { + let mut uninit = ::std::mem::MaybeUninit::< + &mut flexarray_template, + >::uninit(); + (uninit.as_mut_ptr() as *mut *mut flexarray_template) + .write(::std::ptr::from_raw_parts_mut(ptr as *mut (), len)); + uninit + } +} +impl Default for flexarray_template { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct flexarray_ref { + pub things: *mut flexarray, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of flexarray_ref"][::std::mem::size_of::() - 8usize]; + ["Alignment of flexarray_ref"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: flexarray_ref::things", + ][::std::mem::offset_of!(flexarray_ref, things) - 0usize]; +}; +impl Default for flexarray_ref { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default)] +pub struct flexarray_bogus_zero_fam { + pub count: ::std::os::raw::c_int, + pub data1: __IncompleteArrayField<::std::os::raw::c_int>, + pub data2: FAM, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of flexarray_bogus_zero_fam", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of flexarray_bogus_zero_fam", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: flexarray_bogus_zero_fam::count", + ][::std::mem::offset_of!(flexarray_bogus_zero_fam, count) - 0usize]; + [ + "Offset of field: flexarray_bogus_zero_fam::data1", + ][::std::mem::offset_of!(flexarray_bogus_zero_fam, data1) - 4usize]; + [ + "Offset of field: flexarray_bogus_zero_fam::data2", + ][::std::mem::offset_of!(flexarray_bogus_zero_fam, data2) - 4usize]; +}; +impl flexarray_bogus_zero_fam<[::std::os::raw::c_char]> { + pub fn layout(len: usize) -> ::std::alloc::Layout { + unsafe { + let p: *const Self = ::std::ptr::from_raw_parts( + ::std::ptr::null::<()>(), + len, + ); + ::std::alloc::Layout::for_value_raw(p) + } + } + #[inline] + pub fn fixed( + &self, + ) -> (&flexarray_bogus_zero_fam<[::std::os::raw::c_char; 0]>, usize) { + unsafe { + let (ptr, len) = (self as *const Self).to_raw_parts(); + ( + &*(ptr as *const flexarray_bogus_zero_fam<[::std::os::raw::c_char; 0]>), + len, + ) + } + } + #[inline] + pub fn fixed_mut( + &mut self, + ) -> (&mut flexarray_bogus_zero_fam<[::std::os::raw::c_char; 0]>, usize) { + unsafe { + let (ptr, len) = (self as *mut Self).to_raw_parts(); + ( + &mut *(ptr + as *mut flexarray_bogus_zero_fam<[::std::os::raw::c_char; 0]>), + len, + ) + } + } +} +impl flexarray_bogus_zero_fam<[::std::os::raw::c_char; 0]> { + /// Convert a sized prefix to an unsized structure with the given length. + /// + /// SAFETY: Underlying storage is initialized up to at least `len` elements. + pub unsafe fn flex_ref( + &self, + len: usize, + ) -> &flexarray_bogus_zero_fam<[::std::os::raw::c_char]> { + Self::flex_ptr(self, len) + } + /// Convert a mutable sized prefix to an unsized structure with the given length. + /// + /// SAFETY: Underlying storage is initialized up to at least `len` elements. + #[inline] + pub unsafe fn flex_ref_mut( + &mut self, + len: usize, + ) -> &mut flexarray_bogus_zero_fam<[::std::os::raw::c_char]> { + Self::flex_ptr_mut(self, len).assume_init() + } + /// Construct DST variant from a pointer and a size. + /// + /// NOTE: lifetime of returned reference is not tied to any underlying storage. + /// SAFETY: `ptr` is valid. Underlying storage is fully initialized up to at least `len` elements. + #[inline] + pub unsafe fn flex_ptr<'unbounded>( + ptr: *const Self, + len: usize, + ) -> &'unbounded flexarray_bogus_zero_fam<[::std::os::raw::c_char]> { + &*::std::ptr::from_raw_parts(ptr as *const (), len) + } + /// Construct mutable DST variant from a pointer and a + /// size. The returned `&mut` reference is initialized + /// pointing to memory referenced by `ptr`, but there's + /// no requirement that that memory be initialized. + /// + /// NOTE: lifetime of returned reference is not tied to any underlying storage. + /// SAFETY: `ptr` is valid. Underlying storage has space for at least `len` elements. + #[inline] + pub unsafe fn flex_ptr_mut<'unbounded>( + ptr: *mut Self, + len: usize, + ) -> ::std::mem::MaybeUninit< + &'unbounded mut flexarray_bogus_zero_fam<[::std::os::raw::c_char]>, + > { + let mut uninit = ::std::mem::MaybeUninit::< + &mut flexarray_bogus_zero_fam<[::std::os::raw::c_char]>, + >::uninit(); + (uninit.as_mut_ptr() + as *mut *mut flexarray_bogus_zero_fam<[::std::os::raw::c_char]>) + .write(::std::ptr::from_raw_parts_mut(ptr as *mut (), len)); + uninit + } +} +#[repr(C)] +#[repr(align(128))] +#[derive(Debug)] +pub struct flexarray_align { + pub count: ::std::os::raw::c_int, + pub data: FAM, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of flexarray_align"][::std::mem::size_of::() - 128usize]; + [ + "Alignment of flexarray_align", + ][::std::mem::align_of::() - 128usize]; + [ + "Offset of field: flexarray_align::count", + ][::std::mem::offset_of!(flexarray_align, count) - 0usize]; + [ + "Offset of field: flexarray_align::data", + ][::std::mem::offset_of!(flexarray_align, data) - 4usize]; +}; +impl flexarray_align<[::std::os::raw::c_int]> { + pub fn layout(len: usize) -> ::std::alloc::Layout { + unsafe { + let p: *const Self = ::std::ptr::from_raw_parts( + ::std::ptr::null::<()>(), + len, + ); + ::std::alloc::Layout::for_value_raw(p) + } + } + #[inline] + pub fn fixed(&self) -> (&flexarray_align<[::std::os::raw::c_int; 0]>, usize) { + unsafe { + let (ptr, len) = (self as *const Self).to_raw_parts(); + (&*(ptr as *const flexarray_align<[::std::os::raw::c_int; 0]>), len) + } + } + #[inline] + pub fn fixed_mut( + &mut self, + ) -> (&mut flexarray_align<[::std::os::raw::c_int; 0]>, usize) { + unsafe { + let (ptr, len) = (self as *mut Self).to_raw_parts(); + (&mut *(ptr as *mut flexarray_align<[::std::os::raw::c_int; 0]>), len) + } + } +} +impl flexarray_align<[::std::os::raw::c_int; 0]> { + /// Convert a sized prefix to an unsized structure with the given length. + /// + /// SAFETY: Underlying storage is initialized up to at least `len` elements. + pub unsafe fn flex_ref( + &self, + len: usize, + ) -> &flexarray_align<[::std::os::raw::c_int]> { + Self::flex_ptr(self, len) + } + /// Convert a mutable sized prefix to an unsized structure with the given length. + /// + /// SAFETY: Underlying storage is initialized up to at least `len` elements. + #[inline] + pub unsafe fn flex_ref_mut( + &mut self, + len: usize, + ) -> &mut flexarray_align<[::std::os::raw::c_int]> { + Self::flex_ptr_mut(self, len).assume_init() + } + /// Construct DST variant from a pointer and a size. + /// + /// NOTE: lifetime of returned reference is not tied to any underlying storage. + /// SAFETY: `ptr` is valid. Underlying storage is fully initialized up to at least `len` elements. + #[inline] + pub unsafe fn flex_ptr<'unbounded>( + ptr: *const Self, + len: usize, + ) -> &'unbounded flexarray_align<[::std::os::raw::c_int]> { + &*::std::ptr::from_raw_parts(ptr as *const (), len) + } + /// Construct mutable DST variant from a pointer and a + /// size. The returned `&mut` reference is initialized + /// pointing to memory referenced by `ptr`, but there's + /// no requirement that that memory be initialized. + /// + /// NOTE: lifetime of returned reference is not tied to any underlying storage. + /// SAFETY: `ptr` is valid. Underlying storage has space for at least `len` elements. + #[inline] + pub unsafe fn flex_ptr_mut<'unbounded>( + ptr: *mut Self, + len: usize, + ) -> ::std::mem::MaybeUninit< + &'unbounded mut flexarray_align<[::std::os::raw::c_int]>, + > { + let mut uninit = ::std::mem::MaybeUninit::< + &mut flexarray_align<[::std::os::raw::c_int]>, + >::uninit(); + (uninit.as_mut_ptr() as *mut *mut flexarray_align<[::std::os::raw::c_int]>) + .write(::std::ptr::from_raw_parts_mut(ptr as *mut (), len)); + uninit + } +} +impl Default for flexarray_align<[::std::os::raw::c_int; 0]> { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/float128.rs b/bindgen-tests/tests/expectations/tests/float128.rs new file mode 100644 index 0000000000..fe64295a68 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/float128.rs @@ -0,0 +1 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] \ No newline at end of file diff --git a/bindgen-tests/tests/expectations/tests/float16.rs b/bindgen-tests/tests/expectations/tests/float16.rs new file mode 100644 index 0000000000..2066b71801 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/float16.rs @@ -0,0 +1,44 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[derive(PartialEq, Copy, Clone, Hash, Debug, Default)] +#[repr(transparent)] +pub struct __BindgenFloat16(pub u16); +unsafe extern "C" { + pub static mut global: __BindgenFloat16; +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, PartialEq)] +pub struct Test__Float16 { + pub f: __BindgenFloat16, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Test__Float16"][::std::mem::size_of::() - 2usize]; + ["Alignment of Test__Float16"][::std::mem::align_of::() - 2usize]; + [ + "Offset of field: Test__Float16::f", + ][::std::mem::offset_of!(Test__Float16, f) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Test__Float16Ref { + pub f: *mut __BindgenFloat16, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Test__Float16Ref"][::std::mem::size_of::() - 8usize]; + [ + "Alignment of Test__Float16Ref", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: Test__Float16Ref::f", + ][::std::mem::offset_of!(Test__Float16Ref, f) - 0usize]; +}; +impl Default for Test__Float16Ref { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/forward-declaration-autoptr.rs b/bindgen-tests/tests/expectations/tests/forward-declaration-autoptr.rs new file mode 100644 index 0000000000..b74b408841 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/forward-declaration-autoptr.rs @@ -0,0 +1,50 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Foo { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct RefPtr { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub m_inner: *mut T, +} +impl Default for RefPtr { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Bar { + pub m_member: RefPtr, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 8usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Bar::m_member"][::std::mem::offset_of!(Bar, m_member) - 0usize]; +}; +impl Default for Bar { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: RefPtr_open0_Foo_close0", + ][::std::mem::size_of::>() - 8usize]; + [ + "Align of template specialization: RefPtr_open0_Foo_close0", + ][::std::mem::align_of::>() - 8usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/forward-enum-decl.rs b/bindgen-tests/tests/expectations/tests/forward-enum-decl.rs new file mode 100644 index 0000000000..9949b39aae --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/forward-enum-decl.rs @@ -0,0 +1,7 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum CSSPseudoClassType { + empty = 0, + link = 1, +} diff --git a/bindgen-tests/tests/expectations/tests/forward-inherit-struct-with-fields.rs b/bindgen-tests/tests/expectations/tests/forward-inherit-struct-with-fields.rs new file mode 100644 index 0000000000..069c76fead --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/forward-inherit-struct-with-fields.rs @@ -0,0 +1,32 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct js_RootedBase { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub foo: *mut T, + pub next: *mut Rooted, +} +impl Default for js_RootedBase { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Rooted { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub _base: js_RootedBase, +} +impl Default for Rooted { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/forward-inherit-struct.rs b/bindgen-tests/tests/expectations/tests/forward-inherit-struct.rs new file mode 100644 index 0000000000..52888c4626 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/forward-inherit-struct.rs @@ -0,0 +1,20 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct js_RootedBase { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Rooted { + pub _address: u8, +} +impl Default for Rooted { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/forward_declared_complex_types.rs b/bindgen-tests/tests/expectations/tests/forward_declared_complex_types.rs new file mode 100644 index 0000000000..79554d58e4 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/forward_declared_complex_types.rs @@ -0,0 +1,58 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo_empty { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo_empty"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo_empty"][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Foo { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Bar { + pub f: *mut Foo, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 8usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Bar::f"][::std::mem::offset_of!(Bar, f) - 0usize]; +}; +impl Default for Bar { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +unsafe extern "C" { + #[link_name = "\u{1}_Z10baz_structP3Foo"] + pub fn baz_struct(f: *mut Foo); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Union { + _unused: [u8; 0], +} +unsafe extern "C" { + #[link_name = "\u{1}_Z9baz_unionP5Union"] + pub fn baz_union(u: *mut Union); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Quux { + _unused: [u8; 0], +} +unsafe extern "C" { + #[link_name = "\u{1}_Z9baz_classP4Quux"] + pub fn baz_class(q: *mut Quux); +} diff --git a/bindgen-tests/tests/expectations/tests/forward_declared_opaque.rs b/bindgen-tests/tests/expectations/tests/forward_declared_opaque.rs new file mode 100644 index 0000000000..1f92194045 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/forward_declared_opaque.rs @@ -0,0 +1,11 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct a { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct b { + _unused: [u8; 0], +} diff --git a/bindgen-tests/tests/expectations/tests/forward_declared_struct.rs b/bindgen-tests/tests/expectations/tests/forward_declared_struct.rs new file mode 100644 index 0000000000..1f6dfd0f58 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/forward_declared_struct.rs @@ -0,0 +1,23 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct a { + pub b: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of a"][::std::mem::size_of::() - 4usize]; + ["Alignment of a"][::std::mem::align_of::() - 4usize]; + ["Offset of field: a::b"][::std::mem::offset_of!(a, b) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct c { + pub d: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of c"][::std::mem::size_of::() - 4usize]; + ["Alignment of c"][::std::mem::align_of::() - 4usize]; + ["Offset of field: c::d"][::std::mem::offset_of!(c, d) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/func_proto.rs b/bindgen-tests/tests/expectations/tests/func_proto.rs new file mode 100644 index 0000000000..496f595a0d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/func_proto.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type foo = ::std::option::Option< + unsafe extern "C" fn(bar: ::std::os::raw::c_int) -> ::std::os::raw::c_int, +>; diff --git a/bindgen-tests/tests/expectations/tests/func_ptr.rs b/bindgen-tests/tests/expectations/tests/func_ptr.rs new file mode 100644 index 0000000000..b91bdba872 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/func_ptr.rs @@ -0,0 +1,9 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub static mut foo: ::std::option::Option< + unsafe extern "C" fn( + x: ::std::os::raw::c_int, + y: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >; +} diff --git a/bindgen-tests/tests/expectations/tests/func_ptr_in_struct.rs b/bindgen-tests/tests/expectations/tests/func_ptr_in_struct.rs new file mode 100644 index 0000000000..308bb069e0 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/func_ptr_in_struct.rs @@ -0,0 +1,19 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum baz { + __bindgen_cannot_repr_c_on_empty_enum = 0, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Foo { + pub bar: ::std::option::Option< + unsafe extern "C" fn(x: ::std::os::raw::c_int, y: ::std::os::raw::c_int) -> baz, + >, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 8usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Foo::bar"][::std::mem::offset_of!(Foo, bar) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/func_ptr_return_type.rs b/bindgen-tests/tests/expectations/tests/func_ptr_return_type.rs new file mode 100644 index 0000000000..504eefdfb1 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/func_ptr_return_type.rs @@ -0,0 +1,9 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn func() -> ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >; +} diff --git a/bindgen-tests/tests/expectations/tests/func_return_must_use.rs b/bindgen-tests/tests/expectations/tests/func_return_must_use.rs new file mode 100644 index 0000000000..904c71cbe3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/func_return_must_use.rs @@ -0,0 +1,56 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type MustUseInt = ::std::os::raw::c_int; +unsafe extern "C" { + #[must_use] + pub fn return_int() -> MustUseInt; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +#[must_use] +pub struct MustUseStruct { + _unused: [u8; 0], +} +unsafe extern "C" { + #[must_use] + pub fn return_struct() -> MustUseStruct; +} +///
+pub type AnnotatedInt = ::std::os::raw::c_int; +unsafe extern "C" { + #[must_use] + pub fn return_annotated_int() -> AnnotatedInt; +} +unsafe extern "C" { + pub fn return_plain_int() -> ::std::os::raw::c_int; +} +///
+#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +#[must_use] +pub struct AnnotatedStruct {} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of AnnotatedStruct"][::std::mem::size_of::() - 0usize]; + ["Alignment of AnnotatedStruct"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[must_use] + pub fn return_annotated_struct() -> AnnotatedStruct; +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct PlainStruct {} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of PlainStruct"][::std::mem::size_of::() - 0usize]; + ["Alignment of PlainStruct"][::std::mem::align_of::() - 1usize]; +}; +///
+pub type TypedefPlainStruct = PlainStruct; +unsafe extern "C" { + pub fn return_plain_struct() -> PlainStruct; +} +unsafe extern "C" { + #[must_use] + pub fn return_typedef_struct() -> TypedefPlainStruct; +} diff --git a/bindgen-tests/tests/expectations/tests/func_with_array_arg.rs b/bindgen-tests/tests/expectations/tests/func_with_array_arg.rs new file mode 100644 index 0000000000..20bdc4ac27 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/func_with_array_arg.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn f(x: *mut ::std::os::raw::c_int); +} diff --git a/bindgen-tests/tests/expectations/tests/func_with_func_ptr_arg.rs b/bindgen-tests/tests/expectations/tests/func_with_func_ptr_arg.rs new file mode 100644 index 0000000000..56cf40fb59 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/func_with_func_ptr_arg.rs @@ -0,0 +1,14 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn foo(bar: ::std::option::Option); +} +unsafe extern "C" { + pub fn bar( + one: ::std::option::Option< + unsafe extern "C" fn(a: ::std::os::raw::c_int, b: ::std::os::raw::c_int), + >, + two: ::std::option::Option< + unsafe extern "C" fn(c: ::std::os::raw::c_int, d: ::std::os::raw::c_int), + >, + ); +} diff --git a/bindgen-tests/tests/expectations/tests/function-typedef-stdcall.rs b/bindgen-tests/tests/expectations/tests/function-typedef-stdcall.rs new file mode 100644 index 0000000000..3b08e0988c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/function-typedef-stdcall.rs @@ -0,0 +1,11 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type PFN_VIGEM_X360_NOTIFICATION = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_uchar, + arg4: ::std::os::raw::c_uchar, + arg5: ::std::os::raw::c_uchar, + arg6: *mut ::std::os::raw::c_void, + ), +>; diff --git a/bindgen-tests/tests/expectations/tests/gen-constructors-neg.rs b/bindgen-tests/tests/expectations/tests/gen-constructors-neg.rs new file mode 100644 index 0000000000..551dff82cf --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/gen-constructors-neg.rs @@ -0,0 +1,11 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/gen-constructors.rs b/bindgen-tests/tests/expectations/tests/gen-constructors.rs new file mode 100644 index 0000000000..80e6a25d70 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/gen-constructors.rs @@ -0,0 +1,23 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN3FooC1Ei"] + pub fn Foo_Foo(this: *mut Foo, a: ::std::os::raw::c_int); +} +impl Foo { + #[inline] + pub unsafe fn new(a: ::std::os::raw::c_int) -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + Foo_Foo(__bindgen_tmp.as_mut_ptr(), a); + __bindgen_tmp.assume_init() + } +} diff --git a/bindgen-tests/tests/expectations/tests/gen-destructors-neg.rs b/bindgen-tests/tests/expectations/tests/gen-destructors-neg.rs new file mode 100644 index 0000000000..77b6a07bb1 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/gen-destructors-neg.rs @@ -0,0 +1,12 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default)] +pub struct Foo { + pub bar: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Foo::bar"][::std::mem::offset_of!(Foo, bar) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/gen-destructors.rs b/bindgen-tests/tests/expectations/tests/gen-destructors.rs new file mode 100644 index 0000000000..c860c9985f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/gen-destructors.rs @@ -0,0 +1,22 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default)] +pub struct Foo { + pub bar: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Foo::bar"][::std::mem::offset_of!(Foo, bar) - 0usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN3FooD1Ev"] + pub fn Foo_Foo_destructor(this: *mut Foo); +} +impl Foo { + #[inline] + pub unsafe fn destruct(&mut self) { + Foo_Foo_destructor(self) + } +} diff --git a/bindgen-tests/tests/expectations/tests/generate-inline.rs b/bindgen-tests/tests/expectations/tests/generate-inline.rs new file mode 100644 index 0000000000..c100f3936c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/generate-inline.rs @@ -0,0 +1,25 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN3Foo3barEv"] + pub fn Foo_bar() -> ::std::os::raw::c_int; +} +impl Foo { + #[inline] + pub unsafe fn bar() -> ::std::os::raw::c_int { + Foo_bar() + } +} +unsafe extern "C" { + #[link_name = "\u{1}_Z3foov"] + pub fn foo() -> ::std::os::raw::c_int; +} diff --git a/bindgen-tests/tests/expectations/tests/generated/README.md b/bindgen-tests/tests/expectations/tests/generated/README.md new file mode 100644 index 0000000000..b4e8cabbf6 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/generated/README.md @@ -0,0 +1,4 @@ +# Generated C, C++, Header files + +This directory contains files for features where extra files are generated +as a part of the feature. For example, `--wrap-static-fns`. diff --git a/bindgen-tests/tests/expectations/tests/generated/wrap_static_fns.c b/bindgen-tests/tests/expectations/tests/generated/wrap_static_fns.c new file mode 100644 index 0000000000..a8fd5045d2 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/generated/wrap_static_fns.c @@ -0,0 +1,32 @@ +#include "tests/headers/wrap-static-fns.h" + +// Static wrappers + +int foo__extern(void) { return foo(); } +int bar__extern(void) { return bar(); } +int takes_ptr__extern(int *arg) { return takes_ptr(arg); } +int takes_fn_ptr__extern(int (*f) (int)) { return takes_fn_ptr(f); } +int takes_fn__extern(int (f) (int)) { return takes_fn(f); } +int takes_alias__extern(func f) { return takes_alias(f); } +int takes_qualified__extern(const int *const *arg) { return takes_qualified(arg); } +enum foo takes_enum__extern(const enum foo f) { return takes_enum(f); } +void nevermore__extern(void) { nevermore(); } +int takes_fn_with_no_args__extern(int (f) (void)) { return takes_fn_with_no_args(f); } +void no_extra_argument__extern(__builtin_va_list va) { no_extra_argument(va); } +int many_va_list__extern(int i, __builtin_va_list va1, __builtin_va_list va2) { return many_va_list(i, va1, va2); } +int wrap_as_variadic_fn1__extern(int i, ...) { + int ret; + va_list ap; + + va_start(ap, i); + ret = wrap_as_variadic_fn1(i, ap); + va_end(ap); + return ret; +} +void wrap_as_variadic_fn2__extern(int i, ...) { + va_list ap; + + va_start(ap, i); + wrap_as_variadic_fn2(i, ap); + va_end(ap); +} diff --git a/bindgen-tests/tests/expectations/tests/generated/wrap_static_fns_aarch64_linux.c b/bindgen-tests/tests/expectations/tests/generated/wrap_static_fns_aarch64_linux.c new file mode 100644 index 0000000000..a4269d8505 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/generated/wrap_static_fns_aarch64_linux.c @@ -0,0 +1,14 @@ +#include "tests/headers/wrap-static-fns.h" + +// Static wrappers + +int foo__extern(void) { return foo(); } +int bar__extern(void) { return bar(); } +int takes_ptr__extern(int *arg) { return takes_ptr(arg); } +int takes_fn_ptr__extern(int (*f) (int)) { return takes_fn_ptr(f); } +int takes_fn__extern(int (f) (int)) { return takes_fn(f); } +int takes_alias__extern(func f) { return takes_alias(f); } +int takes_qualified__extern(const int *const *arg) { return takes_qualified(arg); } +enum foo takes_enum__extern(const enum foo f) { return takes_enum(f); } +void nevermore__extern(void) { nevermore(); } +int takes_fn_with_no_args__extern(int (f) (void)) { return takes_fn_with_no_args(f); } diff --git a/bindgen-tests/tests/expectations/tests/i128.rs b/bindgen-tests/tests/expectations/tests/i128.rs new file mode 100644 index 0000000000..e29db491fe --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/i128.rs @@ -0,0 +1,17 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct foo { + pub my_signed: i128, + pub my_unsigned: u128, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 32usize]; + ["Alignment of foo"][::std::mem::align_of::() - 16usize]; + ["Offset of field: foo::my_signed"][::std::mem::offset_of!(foo, my_signed) - 0usize]; + [ + "Offset of field: foo::my_unsigned", + ][::std::mem::offset_of!(foo, my_unsigned) - 16usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/in_class_typedef.rs b/bindgen-tests/tests/expectations/tests/in_class_typedef.rs new file mode 100644 index 0000000000..ccb73520d7 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/in_class_typedef.rs @@ -0,0 +1,14 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +pub type Foo_elem_type = T; +pub type Foo_ptr_type = *mut T; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo_Bar { + pub x: ::std::os::raw::c_int, + pub y: ::std::os::raw::c_int, +} diff --git a/bindgen-tests/tests/expectations/tests/incomplete-array-padding.rs b/bindgen-tests/tests/expectations/tests/incomplete-array-padding.rs new file mode 100644 index 0000000000..a90fe54bf3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/incomplete-array-padding.rs @@ -0,0 +1,251 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Default)] +pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); +impl __IncompleteArrayField { + #[inline] + pub const fn new() -> Self { + __IncompleteArrayField(::std::marker::PhantomData, []) + } + #[inline] + pub fn as_ptr(&self) -> *const T { + self as *const _ as *const T + } + #[inline] + pub fn as_mut_ptr(&mut self) -> *mut T { + self as *mut _ as *mut T + } + #[inline] + pub unsafe fn as_slice(&self, len: usize) -> &[T] { + ::std::slice::from_raw_parts(self.as_ptr(), len) + } + #[inline] + pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { + ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) + } +} +impl ::std::fmt::Debug for __IncompleteArrayField { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + fmt.write_str("__IncompleteArrayField") + } +} +#[repr(C)] +#[derive(Debug)] +pub struct foo { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub b: __IncompleteArrayField<*mut ::std::os::raw::c_void>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 8usize]; + ["Alignment of foo"][::std::mem::align_of::() - 8usize]; + ["Offset of field: foo::b"][::std::mem::offset_of!(foo, b) - 8usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl foo { + #[inline] + pub fn a(&self) -> ::std::os::raw::c_char { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_a(&mut self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn a_raw(this: *const Self) -> ::std::os::raw::c_char { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_a_raw(this: *mut Self, val: ::std::os::raw::c_char) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + a: ::std::os::raw::c_char, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let a: u8 = unsafe { ::std::mem::transmute(a) }; + a as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/infinite-macro.rs b/bindgen-tests/tests/expectations/tests/infinite-macro.rs new file mode 100644 index 0000000000..cf2b32f0ed --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/infinite-macro.rs @@ -0,0 +1,7 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const INFINITY: f64 = f64::INFINITY as _; +pub const NEG_INFINITY: f64 = f64::NEG_INFINITY as _; +pub const NAN: f64 = f64::NAN as _; +pub const F32_INFINITY: f32 = f64::INFINITY as _; +pub const F32_NEG_INFINITY: f32 = f64::NEG_INFINITY as _; +pub const F32_NAN: f32 = f64::NAN as _; diff --git a/bindgen-tests/tests/expectations/tests/inherit-from-template-instantiation-with-vtable.rs b/bindgen-tests/tests/expectations/tests/inherit-from-template-instantiation-with-vtable.rs new file mode 100644 index 0000000000..59e35f7b6c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/inherit-from-template-instantiation-with-vtable.rs @@ -0,0 +1,169 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct BaseWithVtable__bindgen_vtable {} +/// This should have an explicit vtable. +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct BaseWithVtable { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub vtable_: *const BaseWithVtable__bindgen_vtable, + pub t: T, +} +impl Default for BaseWithVtable { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +/// This should not have an explicit vtable. +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct DerivedWithNoVirtualMethods { + pub _base: BaseWithVtable<*mut ::std::os::raw::c_char>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of DerivedWithNoVirtualMethods", + ][::std::mem::size_of::() - 16usize]; + [ + "Alignment of DerivedWithNoVirtualMethods", + ][::std::mem::align_of::() - 8usize]; +}; +impl Default for DerivedWithNoVirtualMethods { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +/// This should not have an explicit vtable. +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct DerivedWithVirtualMethods { + pub _base: BaseWithVtable<*mut ::std::os::raw::c_char>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of DerivedWithVirtualMethods", + ][::std::mem::size_of::() - 16usize]; + [ + "Alignment of DerivedWithVirtualMethods", + ][::std::mem::align_of::() - 8usize]; +}; +impl Default for DerivedWithVirtualMethods { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +/// This should not have any vtable. +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct BaseWithoutVtable { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub u: U, +} +impl Default for BaseWithoutVtable { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +pub struct DerivedWithVtable__bindgen_vtable(::std::os::raw::c_void); +/// This should have an explicit vtable. +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct DerivedWithVtable { + pub vtable_: *const DerivedWithVtable__bindgen_vtable, + pub _base: BaseWithoutVtable<*mut ::std::os::raw::c_char>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of DerivedWithVtable"][::std::mem::size_of::() - 16usize]; + [ + "Alignment of DerivedWithVtable", + ][::std::mem::align_of::() - 8usize]; +}; +impl Default for DerivedWithVtable { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +/// This should not have any vtable. +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct DerivedWithoutVtable { + pub _base: BaseWithoutVtable<*mut ::std::os::raw::c_char>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of DerivedWithoutVtable", + ][::std::mem::size_of::() - 8usize]; + [ + "Alignment of DerivedWithoutVtable", + ][::std::mem::align_of::() - 8usize]; +}; +impl Default for DerivedWithoutVtable { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: BaseWithVtable_open0_ptr_char_close0", + ][::std::mem::size_of::>() - 16usize]; + [ + "Align of template specialization: BaseWithVtable_open0_ptr_char_close0", + ][::std::mem::align_of::>() - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: BaseWithVtable_open0_ptr_char_close0", + ][::std::mem::size_of::>() - 16usize]; + [ + "Align of template specialization: BaseWithVtable_open0_ptr_char_close0", + ][::std::mem::align_of::>() - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: BaseWithoutVtable_open0_ptr_char_close0", + ][::std::mem::size_of::>() - 8usize]; + [ + "Align of template specialization: BaseWithoutVtable_open0_ptr_char_close0", + ][::std::mem::align_of::>() - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: BaseWithoutVtable_open0_ptr_char_close0", + ][::std::mem::size_of::>() - 8usize]; + [ + "Align of template specialization: BaseWithoutVtable_open0_ptr_char_close0", + ][::std::mem::align_of::>() - 8usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/inherit-namespaced.rs b/bindgen-tests/tests/expectations/tests/inherit-namespaced.rs new file mode 100644 index 0000000000..52888c4626 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/inherit-namespaced.rs @@ -0,0 +1,20 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct js_RootedBase { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Rooted { + pub _address: u8, +} +impl Default for Rooted { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/inherit_multiple_interfaces.rs b/bindgen-tests/tests/expectations/tests/inherit_multiple_interfaces.rs new file mode 100644 index 0000000000..da9e519156 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/inherit_multiple_interfaces.rs @@ -0,0 +1,69 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct A__bindgen_vtable {} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct A { + pub vtable_: *const A__bindgen_vtable, + pub member: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A"][::std::mem::size_of::() - 16usize]; + ["Alignment of A"][::std::mem::align_of::() - 8usize]; + ["Offset of field: A::member"][::std::mem::offset_of!(A, member) - 8usize]; +}; +impl Default for A { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +pub struct B__bindgen_vtable {} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct B { + pub vtable_: *const B__bindgen_vtable, + pub member2: *mut ::std::os::raw::c_void, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of B"][::std::mem::size_of::() - 16usize]; + ["Alignment of B"][::std::mem::align_of::() - 8usize]; + ["Offset of field: B::member2"][::std::mem::offset_of!(B, member2) - 8usize]; +}; +impl Default for B { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct C { + pub _base: A, + pub _base_1: B, + pub member3: f32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C"][::std::mem::size_of::() - 40usize]; + ["Alignment of C"][::std::mem::align_of::() - 8usize]; + ["Offset of field: C::member3"][::std::mem::offset_of!(C, member3) - 32usize]; +}; +impl Default for C { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/inherit_named.rs b/bindgen-tests/tests/expectations/tests/inherit_named.rs new file mode 100644 index 0000000000..a371249ab0 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/inherit_named.rs @@ -0,0 +1,21 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Wohoo { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Weeee { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub _base: T, +} +impl Default for Weeee { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/inherit_typedef.rs b/bindgen-tests/tests/expectations/tests/inherit_typedef.rs new file mode 100644 index 0000000000..92320f45ef --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/inherit_typedef.rs @@ -0,0 +1,22 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; +pub type TypedefedFoo = Foo; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Bar { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 1usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/inline-function.rs b/bindgen-tests/tests/expectations/tests/inline-function.rs new file mode 100644 index 0000000000..fe64295a68 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/inline-function.rs @@ -0,0 +1 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] \ No newline at end of file diff --git a/bindgen-tests/tests/expectations/tests/inline_namespace.rs b/bindgen-tests/tests/expectations/tests/inline_namespace.rs new file mode 100644 index 0000000000..df05ab7b9d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/inline_namespace.rs @@ -0,0 +1,22 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod foo { + #[allow(unused_imports)] + use self::super::super::root; + pub type Ty = ::std::os::raw::c_int; + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Bar { + pub baz: root::foo::Ty, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 4usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Bar::baz"][::std::mem::offset_of!(Bar, baz) - 0usize]; + }; +} diff --git a/bindgen-tests/tests/expectations/tests/inline_namespace_allowlist.rs b/bindgen-tests/tests/expectations/tests/inline_namespace_allowlist.rs new file mode 100644 index 0000000000..915a40c654 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/inline_namespace_allowlist.rs @@ -0,0 +1,11 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod std { + #[allow(unused_imports)] + use self::super::super::root; + pub type string = *const ::std::os::raw::c_char; + } +} diff --git a/bindgen-tests/tests/expectations/tests/inline_namespace_conservative.rs b/bindgen-tests/tests/expectations/tests/inline_namespace_conservative.rs new file mode 100644 index 0000000000..6941e74adb --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/inline_namespace_conservative.rs @@ -0,0 +1,27 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod foo { + #[allow(unused_imports)] + use self::super::super::root; + pub mod bar { + #[allow(unused_imports)] + use self::super::super::super::root; + pub type Ty = ::std::os::raw::c_int; + } + pub type Ty = ::std::os::raw::c_longlong; + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Bar { + pub baz: root::foo::bar::Ty, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 4usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Bar::baz"][::std::mem::offset_of!(Bar, baz) - 0usize]; + }; +} diff --git a/bindgen-tests/tests/expectations/tests/inline_namespace_macro.rs b/bindgen-tests/tests/expectations/tests/inline_namespace_macro.rs new file mode 100644 index 0000000000..99ca607d2f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/inline_namespace_macro.rs @@ -0,0 +1,20 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod repro { + #[allow(unused_imports)] + use self::super::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct duration { + pub _address: u8, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of duration"][::std::mem::size_of::() - 1usize]; + ["Alignment of duration"][::std::mem::align_of::() - 1usize]; + }; + } +} diff --git a/bindgen-tests/tests/expectations/tests/inline_namespace_nested.rs b/bindgen-tests/tests/expectations/tests/inline_namespace_nested.rs new file mode 100644 index 0000000000..1474f47ba2 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/inline_namespace_nested.rs @@ -0,0 +1,15 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod ranges { + #[allow(unused_imports)] + use self::super::super::root; + pub mod bar { + #[allow(unused_imports)] + use self::super::super::super::root; + pub const bar: ::std::os::raw::c_int = 0; + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/inline_namespace_no_ns_enabled.rs b/bindgen-tests/tests/expectations/tests/inline_namespace_no_ns_enabled.rs new file mode 100644 index 0000000000..66359bd51b --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/inline_namespace_no_ns_enabled.rs @@ -0,0 +1,47 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug)] +pub struct std_basic_string { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub hider: std_basic_string_Alloc_hider, + pub length: ::std::os::raw::c_ulong, + pub __bindgen_anon_1: std_basic_string__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct std_basic_string_Alloc_hider { + pub storage: *mut ::std::os::raw::c_void, +} +impl Default for std_basic_string_Alloc_hider { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug)] +pub struct std_basic_string__bindgen_ty_1 { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub inline_storage: [CharT; 4usize], +} +impl Default for std_basic_string__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Default for std_basic_string { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/inner-typedef-gh422.rs b/bindgen-tests/tests/expectations/tests/inner-typedef-gh422.rs new file mode 100644 index 0000000000..16b1eb48ea --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/inner-typedef-gh422.rs @@ -0,0 +1,31 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Foo_InnerType { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub t: T, +} +impl Default for Foo_InnerType { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type Bar = InnerType; +unsafe extern "C" { + #[link_name = "\u{1}_Z4funcv"] + pub fn func() -> Bar; +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct InnerType { + pub _address: u8, +} diff --git a/bindgen-tests/tests/expectations/tests/inner_const.rs b/bindgen-tests/tests/expectations/tests/inner_const.rs new file mode 100644 index 0000000000..ad8af7ce35 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/inner_const.rs @@ -0,0 +1,20 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub bar: ::std::os::raw::c_int, +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN3Foo3BOOE"] + pub static mut Foo_BOO: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN3Foo8whateverE"] + pub static mut Foo_whatever: Foo; +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Foo::bar"][::std::mem::offset_of!(Foo, bar) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/inner_template_self.rs b/bindgen-tests/tests/expectations/tests/inner_template_self.rs new file mode 100644 index 0000000000..c8f9799be6 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/inner_template_self.rs @@ -0,0 +1,47 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LinkedList { + pub next: *mut LinkedList, + pub prev: *mut LinkedList, +} +impl Default for LinkedList { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct InstantiateIt { + pub m_list: LinkedList, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of InstantiateIt"][::std::mem::size_of::() - 16usize]; + ["Alignment of InstantiateIt"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: InstantiateIt::m_list", + ][::std::mem::offset_of!(InstantiateIt, m_list) - 0usize]; +}; +impl Default for InstantiateIt { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: LinkedList_open0_int_close0", + ][::std::mem::size_of::() - 16usize]; + [ + "Align of template specialization: LinkedList_open0_int_close0", + ][::std::mem::align_of::() - 8usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/int128_t.rs b/bindgen-tests/tests/expectations/tests/int128_t.rs new file mode 100644 index 0000000000..fe64295a68 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/int128_t.rs @@ -0,0 +1 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] \ No newline at end of file diff --git a/bindgen-tests/tests/expectations/tests/issue-1025-unknown-enum-repr.rs b/bindgen-tests/tests/expectations/tests/issue-1025-unknown-enum-repr.rs new file mode 100644 index 0000000000..6e27b94ca9 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1025-unknown-enum-repr.rs @@ -0,0 +1,7 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct a { + pub _address: u8, +} +pub type a__bindgen_ty_1 = i32; diff --git a/bindgen-tests/tests/expectations/tests/issue-1034.rs b/bindgen-tests/tests/expectations/tests/issue-1034.rs new file mode 100644 index 0000000000..90cc768a94 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1034.rs @@ -0,0 +1,164 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct S2 { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of S2"][::std::mem::size_of::() - 2usize]; + ["Alignment of S2"][::std::mem::align_of::() - 1usize]; +}; +impl S2 { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-1040.rs b/bindgen-tests/tests/expectations/tests/issue-1040.rs new file mode 100644 index 0000000000..788c480424 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1040.rs @@ -0,0 +1,2 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const g_107: ::std::os::raw::c_ulonglong = 18446744073709551615; diff --git a/bindgen-tests/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs b/bindgen-tests/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs new file mode 100644 index 0000000000..50e9283b5a --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs @@ -0,0 +1,164 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct S1 { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of S1"][::std::mem::size_of::() - 3usize]; + ["Alignment of S1"][::std::mem::align_of::() - 1usize]; +}; +impl S1 { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 3usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-1113-template-references.rs b/bindgen-tests/tests/expectations/tests/issue-1113-template-references.rs new file mode 100644 index 0000000000..c0e76d8047 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1113-template-references.rs @@ -0,0 +1,41 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Entry { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub _base: K, + pub mData: V, +} +impl Default for Entry { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct nsBaseHashtable { + pub _address: u8, +} +pub type nsBaseHashtable_EntryType = Entry; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nsBaseHashtable_EntryPtr { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub mEntry: *mut nsBaseHashtable_EntryType, + pub mExistingEntry: bool, +} +impl Default for nsBaseHashtable_EntryPtr { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-1118-using-forward-decl.rs b/bindgen-tests/tests/expectations/tests/issue-1118-using-forward-decl.rs new file mode 100644 index 0000000000..7df1cdb741 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1118-using-forward-decl.rs @@ -0,0 +1,82 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type c = nsTArray; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nsTArray_base { + pub d: *mut ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of nsTArray_base"][::std::mem::size_of::() - 8usize]; + ["Alignment of nsTArray_base"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: nsTArray_base::d", + ][::std::mem::offset_of!(nsTArray_base, d) - 0usize]; +}; +impl Default for nsTArray_base { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nsTArray { + pub _base: nsTArray_base, +} +impl Default for nsTArray { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nsIContent { + pub foo: nsTArray, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of nsIContent"][::std::mem::size_of::() - 8usize]; + ["Alignment of nsIContent"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: nsIContent::foo", + ][::std::mem::offset_of!(nsIContent, foo) - 0usize]; +}; +impl Default for nsIContent { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +unsafe extern "C" { + #[link_name = "\u{1}_Z35Gecko_GetAnonymousContentForElementv"] + pub fn Gecko_GetAnonymousContentForElement() -> *mut nsTArray; +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: nsTArray_open0_ptr_nsIContent_close0", + ][::std::mem::size_of::() - 8usize]; + [ + "Align of template specialization: nsTArray_open0_ptr_nsIContent_close0", + ][::std::mem::align_of::() - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: nsTArray_open0_ptr_nsIContent_close0", + ][::std::mem::size_of::() - 8usize]; + [ + "Align of template specialization: nsTArray_open0_ptr_nsIContent_close0", + ][::std::mem::align_of::() - 8usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/issue-1197-pure-virtual-stuff.rs b/bindgen-tests/tests/expectations/tests/issue-1197-pure-virtual-stuff.rs new file mode 100644 index 0000000000..10c769c38c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1197-pure-virtual-stuff.rs @@ -0,0 +1,22 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct Foo__bindgen_vtable(::std::os::raw::c_void); +#[repr(C)] +#[derive(Debug)] +pub struct Foo { + pub vtable_: *const Foo__bindgen_vtable, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 8usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 8usize]; +}; +impl Default for Foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-bitfield-enum.rs b/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-bitfield-enum.rs new file mode 100644 index 0000000000..5aaff691b4 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-bitfield-enum.rs @@ -0,0 +1,69 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +impl MyDupeEnum { + pub const A: MyDupeEnum = MyDupeEnum(0); + pub const A_alias: MyDupeEnum = MyDupeEnum(0); + pub const B: MyDupeEnum = MyDupeEnum(1); +} +impl ::std::ops::BitOr for MyDupeEnum { + type Output = Self; + #[inline] + fn bitor(self, other: Self) -> Self { + MyDupeEnum(self.0 | other.0) + } +} +impl ::std::ops::BitOrAssign for MyDupeEnum { + #[inline] + fn bitor_assign(&mut self, rhs: MyDupeEnum) { + self.0 |= rhs.0; + } +} +impl ::std::ops::BitAnd for MyDupeEnum { + type Output = Self; + #[inline] + fn bitand(self, other: Self) -> Self { + MyDupeEnum(self.0 & other.0) + } +} +impl ::std::ops::BitAndAssign for MyDupeEnum { + #[inline] + fn bitand_assign(&mut self, rhs: MyDupeEnum) { + self.0 &= rhs.0; + } +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct MyDupeEnum(pub ::std::os::raw::c_uint); +impl MyOtherDupeEnum { + pub const C: MyOtherDupeEnum = MyOtherDupeEnum(0); + pub const C_alias: MyOtherDupeEnum = MyOtherDupeEnum(0); + pub const D: MyOtherDupeEnum = MyOtherDupeEnum(1); +} +impl ::std::ops::BitOr for MyOtherDupeEnum { + type Output = Self; + #[inline] + fn bitor(self, other: Self) -> Self { + MyOtherDupeEnum(self.0 | other.0) + } +} +impl ::std::ops::BitOrAssign for MyOtherDupeEnum { + #[inline] + fn bitor_assign(&mut self, rhs: MyOtherDupeEnum) { + self.0 |= rhs.0; + } +} +impl ::std::ops::BitAnd for MyOtherDupeEnum { + type Output = Self; + #[inline] + fn bitand(self, other: Self) -> Self { + MyOtherDupeEnum(self.0 & other.0) + } +} +impl ::std::ops::BitAndAssign for MyOtherDupeEnum { + #[inline] + fn bitand_assign(&mut self, rhs: MyOtherDupeEnum) { + self.0 &= rhs.0; + } +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct MyOtherDupeEnum(pub ::std::os::raw::c_uint); diff --git a/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-const-mod-bitfield-enum.rs b/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-const-mod-bitfield-enum.rs new file mode 100644 index 0000000000..a69d005623 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-const-mod-bitfield-enum.rs @@ -0,0 +1,17 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod MyDupeEnum { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_uint; + pub const A: Type = 0; + pub const A_alias: Type = 0; + pub const B: Type = 1; +} +pub mod MyOtherDupeEnum { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_uint; + pub const C: Type = 0; + pub const C_alias: Type = 0; + pub const D: Type = 1; +} diff --git a/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-const-mod-enum.rs b/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-const-mod-enum.rs new file mode 100644 index 0000000000..a69d005623 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-const-mod-enum.rs @@ -0,0 +1,17 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod MyDupeEnum { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_uint; + pub const A: Type = 0; + pub const A_alias: Type = 0; + pub const B: Type = 1; +} +pub mod MyOtherDupeEnum { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_uint; + pub const C: Type = 0; + pub const C_alias: Type = 0; + pub const D: Type = 1; +} diff --git a/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-enum.rs b/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-enum.rs new file mode 100644 index 0000000000..f41d6e90ec --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-enum.rs @@ -0,0 +1,19 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +impl MyDupeEnum { + pub const A_alias: MyDupeEnum = MyDupeEnum::A; +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum MyDupeEnum { + A = 0, + B = 1, +} +impl MyOtherDupeEnum { + pub const C_alias: MyOtherDupeEnum = MyOtherDupeEnum::C; +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum MyOtherDupeEnum { + C = 0, + D = 1, +} diff --git a/bindgen-tests/tests/expectations/tests/issue-1216-variadic-member.rs b/bindgen-tests/tests/expectations/tests/issue-1216-variadic-member.rs new file mode 100644 index 0000000000..7c562437e4 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1216-variadic-member.rs @@ -0,0 +1,22 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn f(a: ::std::os::raw::c_int, ...); +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub f: ::std::option::Option< + unsafe extern "C" fn( + p: *mut ::std::os::raw::c_void, + obj: *mut ::std::os::raw::c_void, + a: ::std::os::raw::c_int, + ... + ), + >, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 8usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Foo::f"][::std::mem::offset_of!(Foo, f) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/issue-1238-fwd-no-copy.rs b/bindgen-tests/tests/expectations/tests/issue-1238-fwd-no-copy.rs new file mode 100644 index 0000000000..81e8fed5f3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1238-fwd-no-copy.rs @@ -0,0 +1,7 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug)] +pub struct MyType { + _unused: [u8; 0], +} +pub type MyTypeT = MyType; diff --git a/bindgen-tests/tests/expectations/tests/issue-1281.rs b/bindgen-tests/tests/expectations/tests/issue-1281.rs new file mode 100644 index 0000000000..03c80d21fb --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1281.rs @@ -0,0 +1,35 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct bar { + pub u: foo, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct foo { + pub foo: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::foo"][::std::mem::offset_of!(foo, foo) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of bar"][::std::mem::size_of::() - 4usize]; + ["Alignment of bar"][::std::mem::align_of::() - 4usize]; + ["Offset of field: bar::u"][::std::mem::offset_of!(bar, u) - 0usize]; +}; +pub type bar_t = bar; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct baz { + pub f: foo, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of baz"][::std::mem::size_of::() - 4usize]; + ["Alignment of baz"][::std::mem::align_of::() - 4usize]; + ["Offset of field: baz::f"][::std::mem::offset_of!(baz, f) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/issue-1285.rs b/bindgen-tests/tests/expectations/tests/issue-1285.rs new file mode 100644 index 0000000000..6520163259 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1285.rs @@ -0,0 +1,49 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct foo { + pub bar: foo__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union foo__bindgen_ty_1 { + pub a: ::std::os::raw::c_uint, + pub b: ::std::os::raw::c_ushort, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo__bindgen_ty_1"][::std::mem::size_of::() - 4usize]; + [ + "Alignment of foo__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: foo__bindgen_ty_1::a", + ][::std::mem::offset_of!(foo__bindgen_ty_1, a) - 0usize]; + [ + "Offset of field: foo__bindgen_ty_1::b", + ][::std::mem::offset_of!(foo__bindgen_ty_1, b) - 0usize]; +}; +impl Default for foo__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::bar"][::std::mem::offset_of!(foo, bar) - 0usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-1291.rs b/bindgen-tests/tests/expectations/tests/issue-1291.rs new file mode 100644 index 0000000000..3c3fab3704 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1291.rs @@ -0,0 +1,53 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct RTCRay { + pub org: [f32; 3usize], + pub align0: f32, + pub dir: [f32; 3usize], + pub align1: f32, + pub tnear: f32, + pub tfar: f32, + pub time: f32, + pub mask: ::std::os::raw::c_uint, + pub Ng: [f32; 3usize], + pub align2: f32, + pub u: f32, + pub v: f32, + pub geomID: ::std::os::raw::c_uint, + pub primID: ::std::os::raw::c_uint, + pub instID: ::std::os::raw::c_uint, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of RTCRay"][::std::mem::size_of::() - 96usize]; + ["Alignment of RTCRay"][::std::mem::align_of::() - 16usize]; + ["Offset of field: RTCRay::org"][::std::mem::offset_of!(RTCRay, org) - 0usize]; + [ + "Offset of field: RTCRay::align0", + ][::std::mem::offset_of!(RTCRay, align0) - 12usize]; + ["Offset of field: RTCRay::dir"][::std::mem::offset_of!(RTCRay, dir) - 16usize]; + [ + "Offset of field: RTCRay::align1", + ][::std::mem::offset_of!(RTCRay, align1) - 28usize]; + ["Offset of field: RTCRay::tnear"][::std::mem::offset_of!(RTCRay, tnear) - 32usize]; + ["Offset of field: RTCRay::tfar"][::std::mem::offset_of!(RTCRay, tfar) - 36usize]; + ["Offset of field: RTCRay::time"][::std::mem::offset_of!(RTCRay, time) - 40usize]; + ["Offset of field: RTCRay::mask"][::std::mem::offset_of!(RTCRay, mask) - 44usize]; + ["Offset of field: RTCRay::Ng"][::std::mem::offset_of!(RTCRay, Ng) - 48usize]; + [ + "Offset of field: RTCRay::align2", + ][::std::mem::offset_of!(RTCRay, align2) - 60usize]; + ["Offset of field: RTCRay::u"][::std::mem::offset_of!(RTCRay, u) - 64usize]; + ["Offset of field: RTCRay::v"][::std::mem::offset_of!(RTCRay, v) - 68usize]; + [ + "Offset of field: RTCRay::geomID", + ][::std::mem::offset_of!(RTCRay, geomID) - 72usize]; + [ + "Offset of field: RTCRay::primID", + ][::std::mem::offset_of!(RTCRay, primID) - 76usize]; + [ + "Offset of field: RTCRay::instID", + ][::std::mem::offset_of!(RTCRay, instID) - 80usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/issue-1350-attribute-overloadable.rs b/bindgen-tests/tests/expectations/tests/issue-1350-attribute-overloadable.rs new file mode 100644 index 0000000000..c033570793 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1350-attribute-overloadable.rs @@ -0,0 +1,9 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + #[link_name = "\u{1}_Z11my_functioni"] + pub fn my_function(a: ::std::os::raw::c_int); +} +unsafe extern "C" { + #[link_name = "\u{1}_Z11my_functionPKc"] + pub fn my_function1(a: *const ::std::os::raw::c_char); +} diff --git a/bindgen-tests/tests/expectations/tests/issue-1375-prefixed-functions.rs b/bindgen-tests/tests/expectations/tests/issue-1375-prefixed-functions.rs new file mode 100644 index 0000000000..f5e231ea96 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1375-prefixed-functions.rs @@ -0,0 +1,13 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + #[link_name = "\u{1}my_custom_prefix_var_const_name"] + pub static var_const_name: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}my_custom_prefix_var_mut_name"] + pub static mut var_mut_name: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}my_custom_prefix_function_name"] + pub fn function_name(x: ::std::os::raw::c_int); +} diff --git a/bindgen-tests/tests/expectations/tests/issue-1382-rust-primitive-types.rs b/bindgen-tests/tests/expectations/tests/issue-1382-rust-primitive-types.rs new file mode 100644 index 0000000000..277978d93c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1382-rust-primitive-types.rs @@ -0,0 +1,46 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type i8_ = i8; +pub type u8_ = u8; +pub type i16_ = i16; +pub type u16_ = u16; +pub type i32_ = i32; +pub type u32_ = u32; +pub type i64_ = i64; +pub type u64_ = u64; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub i8_: ::std::os::raw::c_int, + pub u8_: ::std::os::raw::c_int, + pub i16_: ::std::os::raw::c_int, + pub u16_: ::std::os::raw::c_int, + pub i32_: ::std::os::raw::c_int, + pub u32_: ::std::os::raw::c_int, + pub i64_: ::std::os::raw::c_int, + pub u64_: ::std::os::raw::c_int, + pub i128_: ::std::os::raw::c_int, + pub u128_: ::std::os::raw::c_int, + pub isize_: ::std::os::raw::c_int, + pub usize_: ::std::os::raw::c_int, + pub f32_: ::std::os::raw::c_int, + pub f64_: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 56usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Foo::i8_"][::std::mem::offset_of!(Foo, i8_) - 0usize]; + ["Offset of field: Foo::u8_"][::std::mem::offset_of!(Foo, u8_) - 4usize]; + ["Offset of field: Foo::i16_"][::std::mem::offset_of!(Foo, i16_) - 8usize]; + ["Offset of field: Foo::u16_"][::std::mem::offset_of!(Foo, u16_) - 12usize]; + ["Offset of field: Foo::i32_"][::std::mem::offset_of!(Foo, i32_) - 16usize]; + ["Offset of field: Foo::u32_"][::std::mem::offset_of!(Foo, u32_) - 20usize]; + ["Offset of field: Foo::i64_"][::std::mem::offset_of!(Foo, i64_) - 24usize]; + ["Offset of field: Foo::u64_"][::std::mem::offset_of!(Foo, u64_) - 28usize]; + ["Offset of field: Foo::i128_"][::std::mem::offset_of!(Foo, i128_) - 32usize]; + ["Offset of field: Foo::u128_"][::std::mem::offset_of!(Foo, u128_) - 36usize]; + ["Offset of field: Foo::isize_"][::std::mem::offset_of!(Foo, isize_) - 40usize]; + ["Offset of field: Foo::usize_"][::std::mem::offset_of!(Foo, usize_) - 44usize]; + ["Offset of field: Foo::f32_"][::std::mem::offset_of!(Foo, f32_) - 48usize]; + ["Offset of field: Foo::f64_"][::std::mem::offset_of!(Foo, f64_) - 52usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/issue-1435.rs b/bindgen-tests/tests/expectations/tests/issue-1435.rs new file mode 100644 index 0000000000..b50e1f88c0 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1435.rs @@ -0,0 +1,18 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod ns { + #[allow(unused_imports)] + use self::super::super::root; + pub const AB_A: AB = 0; + pub const AB_B: AB = 1; + pub type AB = ::std::os::raw::c_int; + } + pub use self::super::root::ns::AB as AB; + unsafe extern "C" { + #[link_name = "\u{1}_ZL2kA"] + pub static kA: root::AB; + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-1443.rs b/bindgen-tests/tests/expectations/tests/issue-1443.rs new file mode 100644 index 0000000000..ee1ffca8e5 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1443.rs @@ -0,0 +1,94 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Foo { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Bar { + pub f: *const Foo, + pub m: ::std::os::raw::c_uint, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 16usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Bar::f"][::std::mem::offset_of!(Bar, f) - 0usize]; + ["Offset of field: Bar::m"][::std::mem::offset_of!(Bar, m) - 8usize]; +}; +impl Default for Bar { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Baz { + pub f: *mut Foo, + pub m: ::std::os::raw::c_uint, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Baz"][::std::mem::size_of::() - 16usize]; + ["Alignment of Baz"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Baz::f"][::std::mem::offset_of!(Baz, f) - 0usize]; + ["Offset of field: Baz::m"][::std::mem::offset_of!(Baz, m) - 8usize]; +}; +impl Default for Baz { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Tar { + pub f: *const Foo, + pub m: ::std::os::raw::c_uint, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Tar"][::std::mem::size_of::() - 16usize]; + ["Alignment of Tar"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Tar::f"][::std::mem::offset_of!(Tar, f) - 0usize]; + ["Offset of field: Tar::m"][::std::mem::offset_of!(Tar, m) - 8usize]; +}; +impl Default for Tar { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Taz { + pub f: *mut Foo, + pub m: ::std::os::raw::c_uint, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Taz"][::std::mem::size_of::() - 16usize]; + ["Alignment of Taz"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Taz::f"][::std::mem::offset_of!(Taz, f) - 0usize]; + ["Offset of field: Taz::m"][::std::mem::offset_of!(Taz, m) - 8usize]; +}; +impl Default for Taz { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-1454.rs b/bindgen-tests/tests/expectations/tests/issue-1454.rs new file mode 100644 index 0000000000..325ccfd977 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1454.rs @@ -0,0 +1,17 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug)] +pub struct extern_type; +#[repr(C)] +#[derive(Debug)] +pub struct local_type { + pub inner: extern_type, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of local_type"][::std::mem::size_of::() - 0usize]; + ["Alignment of local_type"][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: local_type::inner", + ][::std::mem::offset_of!(local_type, inner) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/issue-1464.rs b/bindgen-tests/tests/expectations/tests/issue-1464.rs new file mode 100644 index 0000000000..fe64295a68 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1464.rs @@ -0,0 +1 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] \ No newline at end of file diff --git a/bindgen-tests/tests/expectations/tests/issue-1488-enum-new-type.rs b/bindgen-tests/tests/expectations/tests/issue-1488-enum-new-type.rs new file mode 100644 index 0000000000..ab4b6fc971 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1488-enum-new-type.rs @@ -0,0 +1,45 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const Foo_A: Foo = 0; +pub const Foo_B: Foo = 1; +pub type Foo = ::std::os::raw::c_uint; +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct FooAlias(pub Foo); +pub mod Bar { + #[allow(unused_imports)] + use super::*; + pub type Type = ::std::os::raw::c_uint; + pub const C: Type = 0; + pub const D: Type = 1; +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct BarAlias(pub Bar::Type); +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum Qux { + E = 0, + F = 1, +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct QuxAlias(pub Qux); +pub const Baz_G: Baz = 0; +pub const Baz_H: Baz = 1; +pub type Baz = ::std::os::raw::c_uint; +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct BazAlias(pub Baz); +impl ::std::ops::Deref for BazAlias { + type Target = Baz; + #[inline] + fn deref(&self) -> &Self::Target { + &self.0 + } +} +impl ::std::ops::DerefMut for BazAlias { + #[inline] + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-1488-options.rs b/bindgen-tests/tests/expectations/tests/issue-1488-options.rs new file mode 100644 index 0000000000..0f6efb93d4 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1488-options.rs @@ -0,0 +1,21 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type OSStatus = ::std::os::raw::c_int; +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct SomePtr(pub *mut ::std::os::raw::c_void); +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct AnotherPtr(pub *mut ::std::os::raw::c_void); +impl ::std::ops::Deref for AnotherPtr { + type Target = *mut ::std::os::raw::c_void; + #[inline] + fn deref(&self) -> &Self::Target { + &self.0 + } +} +impl ::std::ops::DerefMut for AnotherPtr { + #[inline] + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-1488-template-alias-new-type.rs b/bindgen-tests/tests/expectations/tests/issue-1488-template-alias-new-type.rs new file mode 100644 index 0000000000..de43753e9c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1488-template-alias-new-type.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Wrapped(pub T); diff --git a/bindgen-tests/tests/expectations/tests/issue-1498.rs b/bindgen-tests/tests/expectations/tests/issue-1498.rs new file mode 100644 index 0000000000..286d2eb6ee --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1498.rs @@ -0,0 +1,82 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C, packed)] +#[derive(Copy, Clone)] +pub struct rte_memseg { + ///< Start physical address. + pub phys_addr: u64, + pub __bindgen_anon_1: rte_memseg__bindgen_ty_1, + ///< Length of the segment. + pub len: usize, + ///< The pagesize of underlying memory + pub hugepage_sz: u64, + ///< NUMA socket ID. + pub socket_id: i32, + ///< Number of channels. + pub nchannel: u32, + ///< Number of ranks. + pub nrank: u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union rte_memseg__bindgen_ty_1 { + ///< Start virtual address. + pub addr: *mut ::std::os::raw::c_void, + ///< Makes sure addr is always 64 bits + pub addr_64: u64, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_memseg__bindgen_ty_1", + ][::std::mem::size_of::() - 8usize]; + [ + "Alignment of rte_memseg__bindgen_ty_1", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: rte_memseg__bindgen_ty_1::addr", + ][::std::mem::offset_of!(rte_memseg__bindgen_ty_1, addr) - 0usize]; + [ + "Offset of field: rte_memseg__bindgen_ty_1::addr_64", + ][::std::mem::offset_of!(rte_memseg__bindgen_ty_1, addr_64) - 0usize]; +}; +impl Default for rte_memseg__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_memseg"][::std::mem::size_of::() - 44usize]; + ["Alignment of rte_memseg"][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: rte_memseg::phys_addr", + ][::std::mem::offset_of!(rte_memseg, phys_addr) - 0usize]; + [ + "Offset of field: rte_memseg::len", + ][::std::mem::offset_of!(rte_memseg, len) - 16usize]; + [ + "Offset of field: rte_memseg::hugepage_sz", + ][::std::mem::offset_of!(rte_memseg, hugepage_sz) - 24usize]; + [ + "Offset of field: rte_memseg::socket_id", + ][::std::mem::offset_of!(rte_memseg, socket_id) - 32usize]; + [ + "Offset of field: rte_memseg::nchannel", + ][::std::mem::offset_of!(rte_memseg, nchannel) - 36usize]; + [ + "Offset of field: rte_memseg::nrank", + ][::std::mem::offset_of!(rte_memseg, nrank) - 40usize]; +}; +impl Default for rte_memseg { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-1514.rs b/bindgen-tests/tests/expectations/tests/issue-1514.rs new file mode 100644 index 0000000000..aef63037ae --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1514.rs @@ -0,0 +1,36 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Thing { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Thing_Inner { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub ptr: *mut T, +} +impl Default for Thing_Inner { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Thing_AnotherInner { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub _base: Thing_Inner, +} +impl Default for Thing_AnotherInner { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-1554.rs b/bindgen-tests/tests/expectations/tests/issue-1554.rs new file mode 100644 index 0000000000..7b1a2cd410 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1554.rs @@ -0,0 +1,10 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(feature = "nightly")] +#![feature(non_exhaustive)] +#[repr(u32)] +#[non_exhaustive] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum Planet { + earth = 0, + mars = 1, +} diff --git a/bindgen-tests/tests/expectations/tests/issue-1599-opaque-typedef-to-enum.rs b/bindgen-tests/tests/expectations/tests/issue-1599-opaque-typedef-to-enum.rs new file mode 100644 index 0000000000..325ee4adc4 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1599-opaque-typedef-to-enum.rs @@ -0,0 +1,5 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const a_b: a = 0; +pub const a_c: a = 1; +pub type a = ::std::os::raw::c_uint; +pub type d = u32; diff --git a/bindgen-tests/tests/expectations/tests/issue-1676-macro-namespace-prefix.rs b/bindgen-tests/tests/expectations/tests/issue-1676-macro-namespace-prefix.rs new file mode 100644 index 0000000000..fe64295a68 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1676-macro-namespace-prefix.rs @@ -0,0 +1 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] \ No newline at end of file diff --git a/bindgen-tests/tests/expectations/tests/issue-1947.rs b/bindgen-tests/tests/expectations/tests/issue-1947.rs new file mode 100644 index 0000000000..795b033a12 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1947.rs @@ -0,0 +1,641 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +pub type U8 = ::std::os::raw::c_uchar; +pub type U16 = ::std::os::raw::c_ushort; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct V56AMDY { + pub _bindgen_align: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, + pub MADK: U8, + pub MABR: U8, + pub _bitfield_2: __BindgenBitfieldUnit<[u8; 3usize]>, + pub _rB_: U8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of V56AMDY"][::std::mem::size_of::() - 8usize]; + ["Alignment of V56AMDY"][::std::mem::align_of::() - 2usize]; + ["Offset of field: V56AMDY::MADK"][::std::mem::offset_of!(V56AMDY, MADK) - 2usize]; + ["Offset of field: V56AMDY::MABR"][::std::mem::offset_of!(V56AMDY, MABR) - 3usize]; + ["Offset of field: V56AMDY::_rB_"][::std::mem::offset_of!(V56AMDY, _rB_) - 7usize]; +}; +impl V56AMDY { + #[inline] + pub fn MADZ(&self) -> U16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 10u8) as u16) } + } + #[inline] + pub fn set_MADZ(&mut self, val: U16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 10u8, val as u64) + } + } + #[inline] + pub unsafe fn MADZ_raw(this: *const Self) -> U16 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 10u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_MADZ_raw(this: *mut Self, val: U16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 10u8, + val as u64, + ) + } + } + #[inline] + pub fn MAI0(&self) -> U16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 2u8) as u16) } + } + #[inline] + pub fn set_MAI0(&mut self, val: U16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn MAI0_raw(this: *const Self) -> U16 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 10usize, 2u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_MAI0_raw(this: *mut Self, val: U16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 10usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn MAI1(&self) -> U16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u16) } + } + #[inline] + pub fn set_MAI1(&mut self, val: U16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn MAI1_raw(this: *const Self) -> U16 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 12usize, 2u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_MAI1_raw(this: *mut Self, val: U16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 12usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn MAI2(&self) -> U16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u16) } + } + #[inline] + pub fn set_MAI2(&mut self, val: U16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn MAI2_raw(this: *const Self) -> U16 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 14usize, 2u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_MAI2_raw(this: *mut Self, val: U16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + MADZ: U16, + MAI0: U16, + MAI1: U16, + MAI2: U16, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 10u8, + { + let MADZ: u16 = unsafe { ::std::mem::transmute(MADZ) }; + MADZ as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 10usize, + 2u8, + { + let MAI0: u16 = unsafe { ::std::mem::transmute(MAI0) }; + MAI0 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 12usize, + 2u8, + { + let MAI1: u16 = unsafe { ::std::mem::transmute(MAI1) }; + MAI1 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 14usize, + 2u8, + { + let MAI2: u16 = unsafe { ::std::mem::transmute(MAI2) }; + MAI2 as u64 + }, + ); + __bindgen_bitfield_unit + } + #[inline] + pub fn MATH(&self) -> U16 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 10u8) as u16) } + } + #[inline] + pub fn set_MATH(&mut self, val: U16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_2.set(0usize, 10u8, val as u64) + } + } + #[inline] + pub unsafe fn MATH_raw(this: *const Self) -> U16 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_2), 0usize, 10u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_MATH_raw(this: *mut Self, val: U16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 0usize, + 10u8, + val as u64, + ) + } + } + #[inline] + pub fn MATE(&self) -> U16 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(10usize, 4u8) as u16) } + } + #[inline] + pub fn set_MATE(&mut self, val: U16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_2.set(10usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn MATE_raw(this: *const Self) -> U16 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_2), 10usize, 4u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_MATE_raw(this: *mut Self, val: U16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 10usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn MATW(&self) -> U16 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(14usize, 2u8) as u16) } + } + #[inline] + pub fn set_MATW(&mut self, val: U16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_2.set(14usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn MATW_raw(this: *const Self) -> U16 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_2), 14usize, 2u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_MATW_raw(this: *mut Self, val: U16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 14usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn MASW(&self) -> U8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(16usize, 4u8) as u8) } + } + #[inline] + pub fn set_MASW(&mut self, val: U8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(16usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn MASW_raw(this: *const Self) -> U8 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_2), 16usize, 4u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_MASW_raw(this: *mut Self, val: U8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 16usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn MABW(&self) -> U8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(20usize, 3u8) as u8) } + } + #[inline] + pub fn set_MABW(&mut self, val: U8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(20usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn MABW_raw(this: *const Self) -> U8 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_2), 20usize, 3u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_MABW_raw(this: *mut Self, val: U8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 20usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn MAXN(&self) -> U8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(23usize, 1u8) as u8) } + } + #[inline] + pub fn set_MAXN(&mut self, val: U8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn MAXN_raw(this: *const Self) -> U8 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_2), 23usize, 1u8) + as u8, + ) + } + } + #[inline] + pub unsafe fn set_MAXN_raw(this: *mut Self, val: U8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 23usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_2( + MATH: U16, + MATE: U16, + MATW: U16, + MASW: U8, + MABW: U8, + MAXN: U8, + ) -> __BindgenBitfieldUnit<[u8; 3usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 10u8, + { + let MATH: u16 = unsafe { ::std::mem::transmute(MATH) }; + MATH as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 10usize, + 4u8, + { + let MATE: u16 = unsafe { ::std::mem::transmute(MATE) }; + MATE as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 14usize, + 2u8, + { + let MATW: u16 = unsafe { ::std::mem::transmute(MATW) }; + MATW as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 16usize, + 4u8, + { + let MASW: u8 = unsafe { ::std::mem::transmute(MASW) }; + MASW as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 20usize, + 3u8, + { + let MABW: u8 = unsafe { ::std::mem::transmute(MABW) }; + MABW as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 23usize, + 1u8, + { + let MAXN: u8 = unsafe { ::std::mem::transmute(MAXN) }; + MAXN as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-1977-larger-arrays.rs b/bindgen-tests/tests/expectations/tests/issue-1977-larger-arrays.rs new file mode 100644 index 0000000000..df7a2192ed --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1977-larger-arrays.rs @@ -0,0 +1,36 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct S { + pub large_array: [::std::os::raw::c_char; 33usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of S"][::std::mem::size_of::() - 33usize]; + ["Alignment of S"][::std::mem::align_of::() - 1usize]; + ["Offset of field: S::large_array"][::std::mem::offset_of!(S, large_array) - 0usize]; +}; +impl Default for S { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Hash, PartialEq, Eq)] +pub struct ST { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub large_array: [T; 33usize], +} +impl Default for ST { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-1995.rs b/bindgen-tests/tests/expectations/tests/issue-1995.rs new file mode 100644 index 0000000000..0e36bdd9c9 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-1995.rs @@ -0,0 +1,19 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +/** This is a constant that has a docstring + + And expected to be found in generated bindings code too.*/ +pub const FOO: ::std::os::raw::c_int = 1; +/** This is a constant that has a docstring + + And expected to be found in generated bindings code too.*/ +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Bar { + pub baz: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 4usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Bar::baz"][::std::mem::offset_of!(Bar, baz) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/issue-2019.rs b/bindgen-tests/tests/expectations/tests/issue-2019.rs new file mode 100644 index 0000000000..4c91cf9972 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-2019.rs @@ -0,0 +1,43 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct A { + pub a: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A"][::std::mem::size_of::() - 4usize]; + ["Alignment of A"][::std::mem::align_of::() - 4usize]; + ["Offset of field: A::a"][::std::mem::offset_of!(A, a) - 0usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN1A4makeEv"] + pub fn make() -> A; +} +impl A { + #[inline] + pub unsafe fn make() -> A { + make() + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct B { + pub b: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of B"][::std::mem::size_of::() - 4usize]; + ["Alignment of B"][::std::mem::align_of::() - 4usize]; + ["Offset of field: B::b"][::std::mem::offset_of!(B, b) - 0usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN1B4makeEv"] + pub fn make1() -> B; +} +impl B { + #[inline] + pub unsafe fn make() -> B { + make1() + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-2239-template-dependent-bit-width.rs b/bindgen-tests/tests/expectations/tests/issue-2239-template-dependent-bit-width.rs new file mode 100644 index 0000000000..6ff58b7559 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-2239-template-dependent-bit-width.rs @@ -0,0 +1,13 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct b { + pub _address: u8, +} +pub type b_td = a; +pub type b_ta = a; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct b_foo { + pub _address: u8, +} diff --git a/bindgen-tests/tests/expectations/tests/issue-2556.rs b/bindgen-tests/tests/expectations/tests/issue-2556.rs new file mode 100644 index 0000000000..92fe5026b8 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-2556.rs @@ -0,0 +1,31 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct nsSize { + pub width: ::std::os::raw::c_int, + pub height: ::std::os::raw::c_int, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of nsSize"][::std::mem::size_of::() - 8usize]; + ["Alignment of nsSize"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: nsSize::width", + ][::std::mem::offset_of!(nsSize, width) - 0usize]; + [ + "Offset of field: nsSize::height", + ][::std::mem::offset_of!(nsSize, height) - 4usize]; + }; + pub mod foo { + #[allow(unused_imports)] + use self::super::super::root; + unsafe extern "C" { + #[link_name = "\u{1}_ZN3fooL22kFallbackIntrinsicSizeE"] + pub static kFallbackIntrinsicSize: root::nsSize; + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-2566-cstr.rs b/bindgen-tests/tests/expectations/tests/issue-2566-cstr.rs new file mode 100644 index 0000000000..4227cf2956 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-2566-cstr.rs @@ -0,0 +1,2 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const FOO: &[u8; 4] = b"a\0b\0"; diff --git a/bindgen-tests/tests/expectations/tests/issue-2566.rs b/bindgen-tests/tests/expectations/tests/issue-2566.rs new file mode 100644 index 0000000000..4227cf2956 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-2566.rs @@ -0,0 +1,2 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const FOO: &[u8; 4] = b"a\0b\0"; diff --git a/bindgen-tests/tests/expectations/tests/issue-2618.rs b/bindgen-tests/tests/expectations/tests/issue-2618.rs new file mode 100644 index 0000000000..ecac1ec81e --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-2618.rs @@ -0,0 +1,13 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const val1: u32 = 2147483647; +pub const val2: u32 = 2147483648; +pub const val3: u32 = 4294967295; +pub const val4: u64 = 9223372036854775807; +pub const val5: u64 = 9223372036854775808; +pub const val6: u64 = 18446744073709551615; +pub const val7: u32 = 2147483647; +pub const val8: u32 = 2147483648; +pub const val9: u32 = 4294967295; +pub const val10: u64 = 9223372036854775807; +pub const val11: u64 = 9223372036854775808; +pub const val12: u64 = 18446744073709551615; diff --git a/bindgen-tests/tests/expectations/tests/issue-2695.rs b/bindgen-tests/tests/expectations/tests/issue-2695.rs new file mode 100644 index 0000000000..20a016dbab --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-2695.rs @@ -0,0 +1,19 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C, packed(2))] +#[derive(Debug, Default, Copy, Clone)] +pub struct Test { + pub x: ::std::os::raw::c_ulong, + pub a: ::std::os::raw::c_char, + pub b: ::std::os::raw::c_char, + pub c: ::std::os::raw::c_char, + pub __bindgen_padding_0: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Test"][::std::mem::size_of::() - 12usize]; + ["Alignment of Test"][::std::mem::align_of::() - 2usize]; + ["Offset of field: Test::x"][::std::mem::offset_of!(Test, x) - 0usize]; + ["Offset of field: Test::a"][::std::mem::offset_of!(Test, a) - 8usize]; + ["Offset of field: Test::b"][::std::mem::offset_of!(Test, b) - 9usize]; + ["Offset of field: Test::c"][::std::mem::offset_of!(Test, c) - 10usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/issue-2966.rs b/bindgen-tests/tests/expectations/tests/issue-2966.rs new file mode 100644 index 0000000000..bfdcbd9e2f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-2966.rs @@ -0,0 +1,10 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct pub_var1(pub *const ::std::os::raw::c_char); +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct pubcrate_var2(pub(crate) *const ::std::os::raw::c_char); +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct private_var3(*const ::std::os::raw::c_char); diff --git a/bindgen-tests/tests/expectations/tests/issue-3027.rs b/bindgen-tests/tests/expectations/tests/issue-3027.rs new file mode 100644 index 0000000000..c8c2a7e542 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-3027.rs @@ -0,0 +1,29 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)] + #[repr(C)] + pub struct __BindgenOpaqueArray(pub T); + impl Default for __BindgenOpaqueArray<[T; N]> { + fn default() -> Self { + Self([::default(); N]) + } + } + #[allow(unused_imports)] + use self::super::root; + pub mod regression { + #[allow(unused_imports)] + use self::super::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct C { + pub a: root::__BindgenOpaqueArray<[u8; 3usize]>, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of C"][::std::mem::size_of::() - 3usize]; + ["Alignment of C"][::std::mem::align_of::() - 1usize]; + ["Offset of field: C::a"][::std::mem::offset_of!(C, a) - 0usize]; + }; + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-358.rs b/bindgen-tests/tests/expectations/tests/issue-358.rs new file mode 100644 index 0000000000..ff915e9fba --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-358.rs @@ -0,0 +1,29 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct JS_PersistentRooted { + pub _base: a, +} +impl Default for JS_PersistentRooted { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct a { + pub b: *mut a, +} +impl Default for a { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-372.rs b/bindgen-tests/tests/expectations/tests/issue-372.rs new file mode 100644 index 0000000000..cf00a70743 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-372.rs @@ -0,0 +1,85 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)] + #[repr(C, align(8))] + pub struct __BindgenOpaqueArray8(pub T); + impl Default for __BindgenOpaqueArray8<[T; N]> { + fn default() -> Self { + Self([::default(); N]) + } + } + #[allow(unused_imports)] + use self::super::root; + #[repr(C)] + #[derive(Debug, Copy, Clone)] + pub struct i { + pub j: *mut root::i, + pub k: *mut root::i, + pub l: bool, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of i"][::std::mem::size_of::() - 24usize]; + ["Alignment of i"][::std::mem::align_of::() - 8usize]; + ["Offset of field: i::j"][::std::mem::offset_of!(i, j) - 0usize]; + ["Offset of field: i::k"][::std::mem::offset_of!(i, k) - 8usize]; + ["Offset of field: i::l"][::std::mem::offset_of!(i, l) - 16usize]; + }; + impl Default for i { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } + } + #[repr(C)] + #[derive(Debug, Copy, Clone)] + pub struct d { + pub m: root::i, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of d"][::std::mem::size_of::() - 24usize]; + ["Alignment of d"][::std::mem::align_of::() - 8usize]; + ["Offset of field: d::m"][::std::mem::offset_of!(d, m) - 0usize]; + }; + impl Default for d { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } + } + #[repr(u32)] + #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] + pub enum n { + o = 0, + p = 1, + q = 2, + r = 3, + s = 4, + t = 5, + b = 6, + ae = 7, + e = 8, + ag = 9, + ah = 10, + ai = 11, + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct F { + pub w: root::__BindgenOpaqueArray8<[u8; 264usize]>, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of F"][::std::mem::size_of::() - 264usize]; + ["Alignment of F"][::std::mem::align_of::() - 8usize]; + ["Offset of field: F::w"][::std::mem::offset_of!(F, w) - 0usize]; + }; +} diff --git a/bindgen-tests/tests/expectations/tests/issue-410.rs b/bindgen-tests/tests/expectations/tests/issue-410.rs new file mode 100644 index 0000000000..cda9b6e338 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-410.rs @@ -0,0 +1,35 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod JS { + #[allow(unused_imports)] + use self::super::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Value { + pub _address: u8, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Value"][::std::mem::size_of::() - 1usize]; + ["Alignment of Value"][::std::mem::align_of::() - 1usize]; + }; + unsafe extern "C" { + #[link_name = "\u{1}_ZN2JS5Value1aE10JSWhyMagic"] + pub fn Value_a(this: *mut root::JS::Value, arg1: root::JSWhyMagic); + } + impl Value { + #[inline] + pub unsafe fn a(&mut self, arg1: root::JSWhyMagic) { + Value_a(self, arg1) + } + } + } + #[repr(u32)] + #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] + pub enum JSWhyMagic { + __bindgen_cannot_repr_c_on_empty_enum = 0, + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-446.rs b/bindgen-tests/tests/expectations/tests/issue-446.rs new file mode 100644 index 0000000000..5d625cb311 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-446.rs @@ -0,0 +1,29 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct List { + pub next: *mut List, +} +impl Default for List { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct PersistentRooted { + pub root_list: List, +} +impl Default for PersistentRooted { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-447.rs b/bindgen-tests/tests/expectations/tests/issue-447.rs new file mode 100644 index 0000000000..8867a359a2 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-447.rs @@ -0,0 +1,57 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod mozilla { + #[allow(unused_imports)] + use self::super::super::root; + pub mod detail { + #[allow(unused_imports)] + use self::super::super::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct GuardObjectNotifier { + pub _address: u8, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + [ + "Size of GuardObjectNotifier", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of GuardObjectNotifier", + ][::std::mem::align_of::() - 1usize]; + }; + } + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct JSAutoCompartment { + pub _address: u8, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + [ + "Size of JSAutoCompartment", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of JSAutoCompartment", + ][::std::mem::align_of::() - 1usize]; + }; + unsafe extern "C" { + #[link_name = "\u{1}_ZN17JSAutoCompartmentC1EN7mozilla6detail19GuardObjectNotifierE"] + pub fn JSAutoCompartment_JSAutoCompartment( + this: *mut root::JSAutoCompartment, + arg1: root::mozilla::detail::GuardObjectNotifier, + ); + } + impl JSAutoCompartment { + #[inline] + pub unsafe fn new(arg1: root::mozilla::detail::GuardObjectNotifier) -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + JSAutoCompartment_JSAutoCompartment(__bindgen_tmp.as_mut_ptr(), arg1); + __bindgen_tmp.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-493.rs b/bindgen-tests/tests/expectations/tests/issue-493.rs new file mode 100644 index 0000000000..d2e4ea5375 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-493.rs @@ -0,0 +1,168 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct __BindgenUnionField(::std::marker::PhantomData); +impl __BindgenUnionField { + #[inline] + pub const fn new() -> Self { + __BindgenUnionField(::std::marker::PhantomData) + } + #[inline] + pub unsafe fn as_ref(&self) -> &T { + ::std::mem::transmute(self) + } + #[inline] + pub unsafe fn as_mut(&mut self) -> &mut T { + ::std::mem::transmute(self) + } +} +impl ::std::default::Default for __BindgenUnionField { + #[inline] + fn default() -> Self { + Self::new() + } +} +impl ::std::clone::Clone for __BindgenUnionField { + #[inline] + fn clone(&self) -> Self { + *self + } +} +impl ::std::marker::Copy for __BindgenUnionField {} +impl ::std::fmt::Debug for __BindgenUnionField { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + fmt.write_str("__BindgenUnionField") + } +} +impl ::std::hash::Hash for __BindgenUnionField { + fn hash(&self, _state: &mut H) {} +} +impl ::std::cmp::PartialEq for __BindgenUnionField { + fn eq(&self, _other: &__BindgenUnionField) -> bool { + true + } +} +impl ::std::cmp::Eq for __BindgenUnionField {} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct basic_string { + pub _address: u8, +} +pub type basic_string_size_type = ::std::os::raw::c_ulonglong; +pub type basic_string_value_type = ::std::os::raw::c_char; +pub type basic_string_pointer = *mut basic_string_value_type; +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct basic_string___long { + pub __cap_: basic_string_size_type, + pub __size_: basic_string_size_type, + pub __data_: basic_string_pointer, +} +impl Default for basic_string___long { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub const basic_string___min_cap: basic_string__bindgen_ty_1 = basic_string__bindgen_ty_1::__min_cap; +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum basic_string__bindgen_ty_1 { + __min_cap = 0, +} +#[repr(C)] +pub struct basic_string___short { + pub __bindgen_anon_1: basic_string___short__bindgen_ty_1, + pub __data_: *mut basic_string_value_type, +} +#[repr(C)] +pub union basic_string___short__bindgen_ty_1 { + pub __size_: ::std::os::raw::c_uchar, + pub __lx: basic_string_value_type, +} +impl Default for basic_string___short__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Default for basic_string___short { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[repr(align(1))] +pub struct basic_string___ulx { + pub __lx: __BindgenUnionField, + pub __lxx: __BindgenUnionField, + pub bindgen_union_field: [u8; 0usize], +} +impl Default for basic_string___ulx { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub const basic_string___n_words: basic_string__bindgen_ty_2 = basic_string__bindgen_ty_2::__n_words; +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum basic_string__bindgen_ty_2 { + __n_words = 0, +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct basic_string___raw { + pub __words: *mut basic_string_size_type, +} +impl Default for basic_string___raw { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +pub struct basic_string___rep { + pub __bindgen_anon_1: basic_string___rep__bindgen_ty_1, +} +#[repr(C)] +#[repr(align(1))] +pub struct basic_string___rep__bindgen_ty_1 { + pub __l: __BindgenUnionField, + pub __s: __BindgenUnionField, + pub __r: __BindgenUnionField, + pub bindgen_union_field: [u8; 0usize], +} +impl Default for basic_string___rep__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Default for basic_string___rep { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-511.rs b/bindgen-tests/tests/expectations/tests/issue-511.rs new file mode 100644 index 0000000000..9d26b334c3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-511.rs @@ -0,0 +1,13 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub static mut a: *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub static mut b: *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub static c: *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub static d: *const ::std::os::raw::c_char; +} diff --git a/bindgen-tests/tests/expectations/tests/issue-537-repr-packed-n.rs b/bindgen-tests/tests/expectations/tests/issue-537-repr-packed-n.rs new file mode 100644 index 0000000000..881cb9c8ed --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-537-repr-packed-n.rs @@ -0,0 +1,61 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(feature = "nightly")] +/** This should not be opaque; we can see the attributes and can pack the + struct.*/ +#[repr(C, packed)] +#[derive(Debug, Default, Copy, Clone)] +pub struct AlignedToOne { + pub i: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of AlignedToOne"][::std::mem::size_of::() - 4usize]; + ["Alignment of AlignedToOne"][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: AlignedToOne::i", + ][::std::mem::offset_of!(AlignedToOne, i) - 0usize]; +}; +/// This should be packed because Rust 1.33 has `#[repr(packed(N))]`. +#[repr(C, packed(2))] +#[derive(Debug, Default, Copy, Clone)] +pub struct AlignedToTwo { + pub i: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of AlignedToTwo"][::std::mem::size_of::() - 4usize]; + ["Alignment of AlignedToTwo"][::std::mem::align_of::() - 2usize]; + [ + "Offset of field: AlignedToTwo::i", + ][::std::mem::offset_of!(AlignedToTwo, i) - 0usize]; +}; +/** This should not be opaque because although `libclang` doesn't give us the + `#pragma pack(1)`, we can detect that alignment is 1 and add + `#[repr(packed)]` to the struct ourselves.*/ +#[repr(C, packed)] +#[derive(Debug, Default, Copy, Clone)] +pub struct PackedToOne { + pub x: ::std::os::raw::c_int, + pub y: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of PackedToOne"][::std::mem::size_of::() - 8usize]; + ["Alignment of PackedToOne"][::std::mem::align_of::() - 1usize]; + ["Offset of field: PackedToOne::x"][::std::mem::offset_of!(PackedToOne, x) - 0usize]; + ["Offset of field: PackedToOne::y"][::std::mem::offset_of!(PackedToOne, y) - 4usize]; +}; +/// This should be packed because Rust 1.33 has `#[repr(packed(N))]`. +#[repr(C, packed(2))] +#[derive(Debug, Default, Copy, Clone)] +pub struct PackedToTwo { + pub x: ::std::os::raw::c_int, + pub y: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of PackedToTwo"][::std::mem::size_of::() - 8usize]; + ["Alignment of PackedToTwo"][::std::mem::align_of::() - 2usize]; + ["Offset of field: PackedToTwo::x"][::std::mem::offset_of!(PackedToTwo, x) - 0usize]; + ["Offset of field: PackedToTwo::y"][::std::mem::offset_of!(PackedToTwo, y) - 4usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/issue-537.rs b/bindgen-tests/tests/expectations/tests/issue-537.rs new file mode 100644 index 0000000000..d630b9ea4c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-537.rs @@ -0,0 +1,63 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +/** This should not be opaque; we can see the attributes and can pack the + struct.*/ +#[repr(C, packed)] +#[derive(Debug, Default, Copy, Clone)] +pub struct AlignedToOne { + pub i: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of AlignedToOne"][::std::mem::size_of::() - 4usize]; + ["Alignment of AlignedToOne"][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: AlignedToOne::i", + ][::std::mem::offset_of!(AlignedToOne, i) - 0usize]; +}; +/** This should be opaque because although we can see the attributes, Rust before + 1.33 doesn't have `#[repr(packed(N))]`.*/ +#[repr(C, packed(2))] +#[derive(Debug, Default, Copy, Clone)] +pub struct AlignedToTwo { + pub i: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of AlignedToTwo"][::std::mem::size_of::() - 4usize]; + ["Alignment of AlignedToTwo"][::std::mem::align_of::() - 2usize]; + [ + "Offset of field: AlignedToTwo::i", + ][::std::mem::offset_of!(AlignedToTwo, i) - 0usize]; +}; +/** This should not be opaque because although `libclang` doesn't give us the + `#pragma pack(1)`, we can detect that alignment is 1 and add + `#[repr(packed)]` to the struct ourselves.*/ +#[repr(C, packed)] +#[derive(Debug, Default, Copy, Clone)] +pub struct PackedToOne { + pub x: ::std::os::raw::c_int, + pub y: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of PackedToOne"][::std::mem::size_of::() - 8usize]; + ["Alignment of PackedToOne"][::std::mem::align_of::() - 1usize]; + ["Offset of field: PackedToOne::x"][::std::mem::offset_of!(PackedToOne, x) - 0usize]; + ["Offset of field: PackedToOne::y"][::std::mem::offset_of!(PackedToOne, y) - 4usize]; +}; +/** In this case, even if we can detect the weird alignment triggered by + `#pragma pack(2)`, we can't do anything about it because Rust before 1.33 + doesn't have `#[repr(packed(N))]`. Therefore, we must make it opaque.*/ +#[repr(C, packed(2))] +#[derive(Debug, Default, Copy, Clone)] +pub struct PackedToTwo { + pub x: ::std::os::raw::c_int, + pub y: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of PackedToTwo"][::std::mem::size_of::() - 8usize]; + ["Alignment of PackedToTwo"][::std::mem::align_of::() - 2usize]; + ["Offset of field: PackedToTwo::x"][::std::mem::offset_of!(PackedToTwo, x) - 0usize]; + ["Offset of field: PackedToTwo::y"][::std::mem::offset_of!(PackedToTwo, y) - 4usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/issue-544-stylo-creduce-2.rs b/bindgen-tests/tests/expectations/tests/issue-544-stylo-creduce-2.rs new file mode 100644 index 0000000000..a160d0275d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-544-stylo-creduce-2.rs @@ -0,0 +1,25 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)] +#[repr(C)] +pub struct __BindgenOpaqueArray(pub T); +impl Default for __BindgenOpaqueArray<[T; N]> { + fn default() -> Self { + Self([::default(); N]) + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Foo { + pub member: *mut Foo_SecondAlias, +} +pub type Foo_FirstAlias = __BindgenOpaqueArray<[u8; 0usize]>; +pub type Foo_SecondAlias = Foo; +impl Default for Foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-544-stylo-creduce.rs b/bindgen-tests/tests/expectations/tests/issue-544-stylo-creduce.rs new file mode 100644 index 0000000000..b9c42ae12a --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-544-stylo-creduce.rs @@ -0,0 +1,6 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct a { + pub _address: u8, +} diff --git a/bindgen-tests/tests/expectations/tests/issue-569-non-type-template-params-causing-layout-test-failures.rs b/bindgen-tests/tests/expectations/tests/issue-569-non-type-template-params-causing-layout-test-failures.rs new file mode 100644 index 0000000000..567325b82d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-569-non-type-template-params-causing-layout-test-failures.rs @@ -0,0 +1,52 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const ENUM_VARIANT_1: _bindgen_ty_1 = _bindgen_ty_1::ENUM_VARIANT_1; +pub const ENUM_VARIANT_2: _bindgen_ty_1 = _bindgen_ty_1::ENUM_VARIANT_2; +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _bindgen_ty_1 { + ENUM_VARIANT_1 = 0, + ENUM_VARIANT_2 = 1, +} +pub type JS_Alias = u8; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct JS_Base { + pub f: JS_Alias, +} +impl Default for JS_Base { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct JS_AutoIdVector { + pub _base: JS_Base, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of JS_AutoIdVector"][::std::mem::size_of::() - 1usize]; + ["Alignment of JS_AutoIdVector"][::std::mem::align_of::() - 1usize]; +}; +impl Default for JS_AutoIdVector { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: JS_Base_open0_int_close0", + ][::std::mem::size_of::() - 1usize]; + [ + "Align of template specialization: JS_Base_open0_int_close0", + ][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/issue-573-layout-test-failures.rs b/bindgen-tests/tests/expectations/tests/issue-573-layout-test-failures.rs new file mode 100644 index 0000000000..aa5f457792 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-573-layout-test-failures.rs @@ -0,0 +1,28 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Outer { + pub i: u8, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct AutoIdVector { + pub ar: Outer, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of AutoIdVector"][::std::mem::size_of::() - 1usize]; + ["Alignment of AutoIdVector"][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: AutoIdVector::ar", + ][::std::mem::offset_of!(AutoIdVector, ar) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: Outer_open0_int_close0", + ][::std::mem::size_of::() - 1usize]; + [ + "Align of template specialization: Outer_open0_int_close0", + ][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/issue-574-assertion-failure-in-codegen.rs b/bindgen-tests/tests/expectations/tests/issue-574-assertion-failure-in-codegen.rs new file mode 100644 index 0000000000..9968501397 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-574-assertion-failure-in-codegen.rs @@ -0,0 +1,31 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct a { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _bindgen_ty_1 { + pub ar: a, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _bindgen_ty_1"][::std::mem::size_of::<_bindgen_ty_1>() - 1usize]; + ["Alignment of _bindgen_ty_1"][::std::mem::align_of::<_bindgen_ty_1>() - 1usize]; + [ + "Offset of field: _bindgen_ty_1::ar", + ][::std::mem::offset_of!(_bindgen_ty_1, ar) - 0usize]; +}; +unsafe extern "C" { + pub static mut AutoIdVector: _bindgen_ty_1; +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: a_open0_int_close0", + ][::std::mem::size_of::() - 1usize]; + [ + "Align of template specialization: a_open0_int_close0", + ][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/issue-584-stylo-template-analysis-panic.rs b/bindgen-tests/tests/expectations/tests/issue-584-stylo-template-analysis-panic.rs new file mode 100644 index 0000000000..2a85837e3d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-584-stylo-template-analysis-panic.rs @@ -0,0 +1,82 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type RefPtr = T; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct A { + pub _address: u8, +} +pub type A_a = b; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A"][::std::mem::size_of::() - 1usize]; + ["Alignment of A"][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +pub struct e { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub d: RefPtr, +} +impl Default for e { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct f { + pub _address: u8, +} +#[repr(C)] +pub struct g { + pub h: f, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of g"][::std::mem::size_of::() - 1usize]; + ["Alignment of g"][::std::mem::align_of::() - 1usize]; + ["Offset of field: g::h"][::std::mem::offset_of!(g, h) - 0usize]; +}; +impl Default for g { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +pub struct b { + pub _base: g, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of b"][::std::mem::size_of::() - 1usize]; + ["Alignment of b"][::std::mem::align_of::() - 1usize]; +}; +impl Default for b { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +unsafe extern "C" { + #[link_name = "\u{1}_Z25Servo_Element_GetSnapshotv"] + pub fn Servo_Element_GetSnapshot() -> A; +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: f_open0_e_open1_int_close1_close0", + ][::std::mem::size_of::() - 1usize]; + [ + "Align of template specialization: f_open0_e_open1_int_close1_close0", + ][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/issue-638-stylo-cannot-find-T-in-this-scope.rs b/bindgen-tests/tests/expectations/tests/issue-638-stylo-cannot-find-T-in-this-scope.rs new file mode 100644 index 0000000000..db94687737 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-638-stylo-cannot-find-T-in-this-scope.rs @@ -0,0 +1,32 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct RefPtr { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub use_of_t: T, +} +impl Default for RefPtr { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct UsesRefPtrWithAliasedTypeParam { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub member: RefPtr>, +} +pub type UsesRefPtrWithAliasedTypeParam_V = U; +impl Default for UsesRefPtrWithAliasedTypeParam { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-639-typedef-anon-field.rs b/bindgen-tests/tests/expectations/tests/issue-639-typedef-anon-field.rs new file mode 100644 index 0000000000..e940db1103 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-639-typedef-anon-field.rs @@ -0,0 +1,44 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub bar: Foo_Bar, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo_Bar { + pub abc: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo_Bar"][::std::mem::size_of::() - 4usize]; + ["Alignment of Foo_Bar"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Foo_Bar::abc"][::std::mem::offset_of!(Foo_Bar, abc) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Foo::bar"][::std::mem::offset_of!(Foo, bar) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Baz { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Baz_Bar { + pub abc: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Baz_Bar"][::std::mem::size_of::() - 4usize]; + ["Alignment of Baz_Bar"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Baz_Bar::abc"][::std::mem::offset_of!(Baz_Bar, abc) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Baz"][::std::mem::size_of::() - 1usize]; + ["Alignment of Baz"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/issue-643-inner-struct.rs b/bindgen-tests/tests/expectations/tests/issue-643-inner-struct.rs new file mode 100644 index 0000000000..0012c8f6aa --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-643-inner-struct.rs @@ -0,0 +1,94 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Default)] +pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); +impl __IncompleteArrayField { + #[inline] + pub const fn new() -> Self { + __IncompleteArrayField(::std::marker::PhantomData, []) + } + #[inline] + pub fn as_ptr(&self) -> *const T { + self as *const _ as *const T + } + #[inline] + pub fn as_mut_ptr(&mut self) -> *mut T { + self as *mut _ as *mut T + } + #[inline] + pub unsafe fn as_slice(&self, len: usize) -> &[T] { + ::std::slice::from_raw_parts(self.as_ptr(), len) + } + #[inline] + pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { + ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) + } +} +impl ::std::fmt::Debug for __IncompleteArrayField { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + fmt.write_str("__IncompleteArrayField") + } +} +#[repr(C)] +#[derive(Debug)] +pub struct rte_ring { + pub memzone: *mut rte_memzone, + pub prod: rte_ring_prod, + pub cons: rte_ring_cons, + pub ring: __IncompleteArrayField<*mut ::std::os::raw::c_void>, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct rte_ring_prod { + pub watermark: ::std::os::raw::c_uint, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_ring_prod"][::std::mem::size_of::() - 4usize]; + ["Alignment of rte_ring_prod"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_ring_prod::watermark", + ][::std::mem::offset_of!(rte_ring_prod, watermark) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct rte_ring_cons { + pub sc_dequeue: ::std::os::raw::c_uint, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_ring_cons"][::std::mem::size_of::() - 4usize]; + ["Alignment of rte_ring_cons"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_ring_cons::sc_dequeue", + ][::std::mem::offset_of!(rte_ring_cons, sc_dequeue) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_ring"][::std::mem::size_of::() - 16usize]; + ["Alignment of rte_ring"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: rte_ring::memzone", + ][::std::mem::offset_of!(rte_ring, memzone) - 0usize]; + ["Offset of field: rte_ring::prod"][::std::mem::offset_of!(rte_ring, prod) - 8usize]; + [ + "Offset of field: rte_ring::cons", + ][::std::mem::offset_of!(rte_ring, cons) - 12usize]; + [ + "Offset of field: rte_ring::ring", + ][::std::mem::offset_of!(rte_ring, ring) - 16usize]; +}; +impl Default for rte_ring { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct rte_memzone { + pub _address: u8, +} diff --git a/bindgen-tests/tests/expectations/tests/issue-645-cannot-find-type-T-in-this-scope.rs b/bindgen-tests/tests/expectations/tests/issue-645-cannot-find-type-T-in-this-scope.rs new file mode 100644 index 0000000000..82e2ab4c42 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-645-cannot-find-type-T-in-this-scope.rs @@ -0,0 +1,18 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[derive(Clone, Copy, Debug)] +pub struct RefPtr(T); +#[repr(C)] +pub struct HasRefPtr { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub refptr_member: RefPtr>, +} +pub type HasRefPtr_TypedefOfT = T; +impl Default for HasRefPtr { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-648-derive-debug-with-padding.rs b/bindgen-tests/tests/expectations/tests/issue-648-derive-debug-with-padding.rs new file mode 100644 index 0000000000..5d87159f97 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-648-derive-debug-with-padding.rs @@ -0,0 +1,59 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +/** We emit a `[u8; 63usize]` padding field for this struct, which cannot derive + Debug/Hash because 63 is over the hard coded limit.*/ +#[repr(C)] +#[repr(align(64))] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct NoDebug { + pub c: ::std::os::raw::c_char, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of NoDebug"][::std::mem::size_of::() - 64usize]; + ["Alignment of NoDebug"][::std::mem::align_of::() - 64usize]; + ["Offset of field: NoDebug::c"][::std::mem::offset_of!(NoDebug, c) - 0usize]; +}; +impl Default for NoDebug { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +/** This should derive Debug/Hash/PartialEq/Eq because the padding size is less than the max derive + Debug/Hash/PartialEq/Eq impl for arrays. However, we conservatively don't derive Debug/Hash because + we determine Debug derive-ability before we compute padding, which happens at + codegen.*/ +#[repr(C)] +#[repr(align(64))] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct ShouldDeriveDebugButDoesNot { + pub c: [::std::os::raw::c_char; 32usize], + pub d: ::std::os::raw::c_char, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of ShouldDeriveDebugButDoesNot", + ][::std::mem::size_of::() - 64usize]; + [ + "Alignment of ShouldDeriveDebugButDoesNot", + ][::std::mem::align_of::() - 64usize]; + [ + "Offset of field: ShouldDeriveDebugButDoesNot::c", + ][::std::mem::offset_of!(ShouldDeriveDebugButDoesNot, c) - 0usize]; + [ + "Offset of field: ShouldDeriveDebugButDoesNot::d", + ][::std::mem::offset_of!(ShouldDeriveDebugButDoesNot, d) - 32usize]; +}; +impl Default for ShouldDeriveDebugButDoesNot { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-654-struct-fn-collision.rs b/bindgen-tests/tests/expectations/tests/issue-654-struct-fn-collision.rs new file mode 100644 index 0000000000..6bf02be74e --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-654-struct-fn-collision.rs @@ -0,0 +1,9 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct foo { + _unused: [u8; 0], +} +unsafe extern "C" { + pub fn foo() -> ::std::os::raw::c_int; +} diff --git a/bindgen-tests/tests/expectations/tests/issue-662-cannot-find-T-in-this-scope.rs b/bindgen-tests/tests/expectations/tests/issue-662-cannot-find-T-in-this-scope.rs new file mode 100644 index 0000000000..2e68628323 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-662-cannot-find-T-in-this-scope.rs @@ -0,0 +1,46 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct RefPtr { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub a: T, +} +impl Default for RefPtr { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nsMainThreadPtrHolder { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub a: T, +} +impl Default for nsMainThreadPtrHolder { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nsMainThreadPtrHandle { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub mPtr: RefPtr>, +} +impl Default for nsMainThreadPtrHandle { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-662-part-2.rs b/bindgen-tests/tests/expectations/tests/issue-662-part-2.rs new file mode 100644 index 0000000000..9ddcdc5e8d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-662-part-2.rs @@ -0,0 +1,32 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[derive(Clone, Copy, Debug)] +pub struct RefPtr(T); +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nsMainThreadPtrHolder { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub a: T, +} +impl Default for nsMainThreadPtrHolder { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +pub struct nsMainThreadPtrHandle { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub mPtr: RefPtr>, +} +impl Default for nsMainThreadPtrHandle { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-674-1.rs b/bindgen-tests/tests/expectations/tests/issue-674-1.rs new file mode 100644 index 0000000000..1a3dce44d0 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-674-1.rs @@ -0,0 +1,33 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod mozilla { + #[allow(unused_imports)] + use self::super::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Maybe { + pub _address: u8, + } + pub type Maybe_ValueType = T; + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct CapturingContentInfo { + pub a: u8, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + [ + "Size of CapturingContentInfo", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of CapturingContentInfo", + ][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: CapturingContentInfo::a", + ][::std::mem::offset_of!(CapturingContentInfo, a) - 0usize]; + }; +} diff --git a/bindgen-tests/tests/expectations/tests/issue-674-2.rs b/bindgen-tests/tests/expectations/tests/issue-674-2.rs new file mode 100644 index 0000000000..980928fe97 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-674-2.rs @@ -0,0 +1,52 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod JS { + #[allow(unused_imports)] + use self::super::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Rooted { + pub _address: u8, + } + pub type Rooted_ElementType = T; + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct c { + pub b: u8, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of c"][::std::mem::size_of::() - 1usize]; + ["Alignment of c"][::std::mem::align_of::() - 1usize]; + ["Offset of field: c::b"][::std::mem::offset_of!(c, b) - 0usize]; + }; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct B { + pub a: root::c, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of B"][::std::mem::size_of::() - 1usize]; + ["Alignment of B"][::std::mem::align_of::() - 1usize]; + ["Offset of field: B::a"][::std::mem::offset_of!(B, a) - 0usize]; + }; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct StaticRefPtr { + pub _address: u8, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + [ + "Size of template specialization: StaticRefPtr_open0_B_close0", + ][::std::mem::size_of::() - 1usize]; + [ + "Align of template specialization: StaticRefPtr_open0_B_close0", + ][::std::mem::align_of::() - 1usize]; + }; +} diff --git a/bindgen-tests/tests/expectations/tests/issue-674-3.rs b/bindgen-tests/tests/expectations/tests/issue-674-3.rs new file mode 100644 index 0000000000..4e2f26a46f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-674-3.rs @@ -0,0 +1,36 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct nsRefPtrHashtable { + pub _address: u8, + } + pub type nsRefPtrHashtable_UserDataType = *mut PtrType; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct a { + pub b: u8, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of a"][::std::mem::size_of::() - 1usize]; + ["Alignment of a"][::std::mem::align_of::() - 1usize]; + ["Offset of field: a::b"][::std::mem::offset_of!(a, b) - 0usize]; + }; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct nsCSSValue { + pub c: root::a, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of nsCSSValue"][::std::mem::size_of::() - 1usize]; + ["Alignment of nsCSSValue"][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: nsCSSValue::c", + ][::std::mem::offset_of!(nsCSSValue, c) - 0usize]; + }; +} diff --git a/bindgen-tests/tests/expectations/tests/issue-677-nested-ns-specifier.rs b/bindgen-tests/tests/expectations/tests/issue-677-nested-ns-specifier.rs new file mode 100644 index 0000000000..34ec99688a --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-677-nested-ns-specifier.rs @@ -0,0 +1,15 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod foo { + #[allow(unused_imports)] + use self::super::super::root; + pub mod bar { + #[allow(unused_imports)] + use self::super::super::super::root; + pub type bar = ::std::os::raw::c_int; + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-691-template-parameter-virtual.rs b/bindgen-tests/tests/expectations/tests/issue-691-template-parameter-virtual.rs new file mode 100644 index 0000000000..1313d61168 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-691-template-parameter-virtual.rs @@ -0,0 +1,59 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct VirtualMethods__bindgen_vtable {} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VirtualMethods { + pub vtable_: *const VirtualMethods__bindgen_vtable, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of VirtualMethods"][::std::mem::size_of::() - 8usize]; + ["Alignment of VirtualMethods"][::std::mem::align_of::() - 8usize]; +}; +impl Default for VirtualMethods { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Set { + pub bar: ::std::os::raw::c_int, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ServoElementSnapshotTable { + pub _base: Set, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of ServoElementSnapshotTable", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of ServoElementSnapshotTable", + ][::std::mem::align_of::() - 4usize]; +}; +impl Default for ServoElementSnapshotTable { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: Set_open0_VirtualMethods_close0", + ][::std::mem::size_of::() - 4usize]; + [ + "Align of template specialization: Set_open0_VirtualMethods_close0", + ][::std::mem::align_of::() - 4usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/issue-710-must-use-type.rs b/bindgen-tests/tests/expectations/tests/issue-710-must-use-type.rs new file mode 100644 index 0000000000..d7006dd011 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-710-must-use-type.rs @@ -0,0 +1,19 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +#[must_use] +pub struct A { + _unused: [u8; 0], +} +///
+#[repr(C)] +#[derive(Debug, Copy, Clone)] +#[must_use] +pub struct B { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct C { + _unused: [u8; 0], +} diff --git a/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs b/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs new file mode 100644 index 0000000000..bc1951e7d1 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs @@ -0,0 +1,351 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(not(target_os = "windows"))] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _bindgen_align: [u64; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 32usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 32usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 8usize]; +}; +impl Foo { + #[inline] + pub fn m_bitfield(&self) -> ::std::os::raw::c_ulong { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 64u8) as u64) } + } + #[inline] + pub fn set_m_bitfield(&mut self, val: ::std::os::raw::c_ulong) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 64u8, val as u64) + } + } + #[inline] + pub unsafe fn m_bitfield_raw(this: *const Self) -> ::std::os::raw::c_ulong { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 32usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 64u8) + as u64, + ) + } + } + #[inline] + pub unsafe fn set_m_bitfield_raw(this: *mut Self, val: ::std::os::raw::c_ulong) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 32usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 64u8, + val as u64, + ) + } + } + #[inline] + pub fn m_bar(&self) -> ::std::os::raw::c_ulong { + unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 64u8) as u64) } + } + #[inline] + pub fn set_m_bar(&mut self, val: ::std::os::raw::c_ulong) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + self._bitfield_1.set(64usize, 64u8, val as u64) + } + } + #[inline] + pub unsafe fn m_bar_raw(this: *const Self) -> ::std::os::raw::c_ulong { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 32usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 64usize, 64u8) + as u64, + ) + } + } + #[inline] + pub unsafe fn set_m_bar_raw(this: *mut Self, val: ::std::os::raw::c_ulong) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 32usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 64usize, + 64u8, + val as u64, + ) + } + } + #[inline] + pub fn foo(&self) -> ::std::os::raw::c_ulong { + unsafe { ::std::mem::transmute(self._bitfield_1.get(128usize, 1u8) as u64) } + } + #[inline] + pub fn set_foo(&mut self, val: ::std::os::raw::c_ulong) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + self._bitfield_1.set(128usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn foo_raw(this: *const Self) -> ::std::os::raw::c_ulong { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 32usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 128usize, 1u8) + as u64, + ) + } + } + #[inline] + pub unsafe fn set_foo_raw(this: *mut Self, val: ::std::os::raw::c_ulong) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 32usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 128usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bar(&self) -> ::std::os::raw::c_ulong { + unsafe { ::std::mem::transmute(self._bitfield_1.get(192usize, 64u8) as u64) } + } + #[inline] + pub fn set_bar(&mut self, val: ::std::os::raw::c_ulong) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + self._bitfield_1.set(192usize, 64u8, val as u64) + } + } + #[inline] + pub unsafe fn bar_raw(this: *const Self) -> ::std::os::raw::c_ulong { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 32usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 192usize, 64u8) + as u64, + ) + } + } + #[inline] + pub unsafe fn set_bar_raw(this: *mut Self, val: ::std::os::raw::c_ulong) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 32usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 192usize, + 64u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + m_bitfield: ::std::os::raw::c_ulong, + m_bar: ::std::os::raw::c_ulong, + foo: ::std::os::raw::c_ulong, + bar: ::std::os::raw::c_ulong, + ) -> __BindgenBitfieldUnit<[u8; 32usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 32usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 64u8, + { + let m_bitfield: u64 = unsafe { ::std::mem::transmute(m_bitfield) }; + m_bitfield as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 64usize, + 64u8, + { + let m_bar: u64 = unsafe { ::std::mem::transmute(m_bar) }; + m_bar as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 128usize, + 1u8, + { + let foo: u64 = unsafe { ::std::mem::transmute(foo) }; + foo as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 192usize, + 64u8, + { + let bar: u64 = unsafe { ::std::mem::transmute(bar) }; + bar as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-743.rs b/bindgen-tests/tests/expectations/tests/issue-743.rs new file mode 100644 index 0000000000..af3eb5bf6e --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-743.rs @@ -0,0 +1,225 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct S { + pub p: *mut ::std::os::raw::c_void, + pub b: bool, + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, + pub __bindgen_padding_0: [u8; 5usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of S"][::std::mem::size_of::() - 16usize]; + ["Alignment of S"][::std::mem::align_of::() - 8usize]; + ["Offset of field: S::p"][::std::mem::offset_of!(S, p) - 0usize]; + ["Offset of field: S::b"][::std::mem::offset_of!(S, b) - 8usize]; +}; +impl Default for S { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl S { + #[inline] + pub fn u(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) } + } + #[inline] + pub fn set_u(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 16u8, val as u64) + } + } + #[inline] + pub unsafe fn u_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 16u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_u_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 16u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + u: ::std::os::raw::c_uint, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 16u8, + { + let u: u32 = unsafe { ::std::mem::transmute(u) }; + u as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-753.rs b/bindgen-tests/tests/expectations/tests/issue-753.rs new file mode 100644 index 0000000000..3119ec569e --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-753.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const CONST: u32 = 5; +pub const OTHER_CONST: u32 = 6; +pub const LARGE_CONST: u32 = 1536; diff --git a/bindgen-tests/tests/expectations/tests/issue-769-bad-instantiation-test.rs b/bindgen-tests/tests/expectations/tests/issue-769-bad-instantiation-test.rs new file mode 100644 index 0000000000..59a1d9afa3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-769-bad-instantiation-test.rs @@ -0,0 +1,40 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + #[repr(C)] + #[derive(Debug, Copy, Clone)] + pub struct Rooted { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub member: T, + } + impl Default for Rooted { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } + } + pub type AutoValueVector_Alias = ::std::os::raw::c_int; + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + [ + "Size of template specialization: Rooted_open0_int_close0", + ][::std::mem::size_of::>() - 4usize]; + [ + "Align of template specialization: Rooted_open0_int_close0", + ][::std::mem::align_of::>() - 4usize]; + }; + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + [ + "Size of template specialization: Rooted_open0_AutoValueVector_Alias_close0", + ][::std::mem::size_of::>() - 4usize]; + [ + "Align of template specialization: Rooted_open0_AutoValueVector_Alias_close0", + ][::std::mem::align_of::>() - 4usize]; + }; +} diff --git a/bindgen-tests/tests/expectations/tests/issue-801-opaque-sloppiness.rs b/bindgen-tests/tests/expectations/tests/issue-801-opaque-sloppiness.rs new file mode 100644 index 0000000000..90eb048640 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-801-opaque-sloppiness.rs @@ -0,0 +1,32 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct A { + _unused: [u8; 0], +} +#[repr(C)] +#[repr(align(1))] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct B { + pub _bindgen_opaque_blob: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of B"][::std::mem::size_of::() - 1usize]; + ["Alignment of B"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN1B1aE"] + pub static mut B_a: A; +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct C { + pub b: B, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C"][::std::mem::size_of::() - 1usize]; + ["Alignment of C"][::std::mem::align_of::() - 1usize]; + ["Offset of field: C::b"][::std::mem::offset_of!(C, b) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/issue-807-opaque-types-methods-being-generated.rs b/bindgen-tests/tests/expectations/tests/issue-807-opaque-types-methods-being-generated.rs new file mode 100644 index 0000000000..3d3ee5e590 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-807-opaque-types-methods-being-generated.rs @@ -0,0 +1,79 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Pupper { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Pupper"][::std::mem::size_of::() - 1usize]; + ["Alignment of Pupper"][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Doggo { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Doggo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Doggo"][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct SuchWow { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of SuchWow"][::std::mem::size_of::() - 1usize]; + ["Alignment of SuchWow"][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[repr(align(1))] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Opaque { + pub _bindgen_opaque_blob: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Opaque"][::std::mem::size_of::() - 1usize]; + ["Alignment of Opaque"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN6Opaque17eleven_out_of_tenEv"] + pub fn Opaque_eleven_out_of_ten(this: *mut Opaque) -> SuchWow; +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN6OpaqueC1E6Pupper"] + pub fn Opaque_Opaque(this: *mut Opaque, pup: Pupper); +} +impl Opaque { + #[inline] + pub unsafe fn eleven_out_of_ten(&mut self) -> SuchWow { + Opaque_eleven_out_of_ten(self) + } + #[inline] + pub unsafe fn new(pup: Pupper) -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + Opaque_Opaque(__bindgen_tmp.as_mut_ptr(), pup); + __bindgen_tmp.assume_init() + } +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN6Opaque11MAJESTIC_AFE"] + pub static mut Opaque_MAJESTIC_AF: Doggo; +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Allowlisted { + pub some_member: Opaque, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Allowlisted"][::std::mem::size_of::() - 1usize]; + ["Alignment of Allowlisted"][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: Allowlisted::some_member", + ][::std::mem::offset_of!(Allowlisted, some_member) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/issue-816.rs b/bindgen-tests/tests/expectations/tests/issue-816.rs new file mode 100644 index 0000000000..b1494afede --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-816.rs @@ -0,0 +1,2052 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct capabilities { + pub _bindgen_align: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of capabilities"][::std::mem::size_of::() - 16usize]; + ["Alignment of capabilities"][::std::mem::align_of::() - 4usize]; +}; +impl capabilities { + #[inline] + pub fn bit_1(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_1(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_1_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_1_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_2(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_2(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_2_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_2_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_3(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_3(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_3_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_3_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_4(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_4(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_4_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 3usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_4_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_5(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_5(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_5_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_5_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_6(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_6(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_6_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 5usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_6_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_7(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_7(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_7_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 6usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_7_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_8(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_8(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_8_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 7usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_8_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_9(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_9(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_9_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 8usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_9_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_10(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_10(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_10_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 9usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_10_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 9usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_11(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_11(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_11_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 10usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_11_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 10usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_12(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_12(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_12_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 11usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_12_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_13(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_13(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_13_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 12usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_13_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 12usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_14(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_14(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_14_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 13usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_14_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 13usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_15(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_15(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_15_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 14usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_15_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_16(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_16(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_16_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 15usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_16_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 15usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_17(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_17(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_17_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 16usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_17_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_18(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_18(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_18_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 17usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_18_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_19(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_19(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(18usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_19_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 18usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_19_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 18usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_20(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_20(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_20_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 19usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_20_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_21(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_21(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_21_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 20usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_21_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 20usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_22(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_22(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_22_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 21usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_22_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 21usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_23(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_23(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_23_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 22usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_23_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 22usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_24(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_24(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_24_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 23usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_24_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_25(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_25(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_25_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 24usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_25_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_26(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_26(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(25usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_26_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 25usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_26_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 25usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_27(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_27(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(26usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_27_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 26usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_27_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 26usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_28(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_28(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(27usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_28_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 27usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_28_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 27usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_29(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_29(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(28usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_29_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 28usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_29_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 28usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_30(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_30(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(29usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_30_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 29usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_30_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 29usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_31(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_31(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(30usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_31_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 30usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_31_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 30usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_32(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_32(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(31usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_32_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 31usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_32_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 31usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_33(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_33(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(32usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_33_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 32usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_33_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 32usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_34(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_34(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(33usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_34_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 33usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_34_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 33usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_35(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_35(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(34usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_35_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 34usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_35_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 34usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_36(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_36(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(35usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_36_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 35usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_36_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 35usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_37(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(36usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_37(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(36usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_37_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 36usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_37_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 36usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_38(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_38(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(37usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_38_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 37usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_38_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 37usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_39(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_39(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(38usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_39_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 38usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_39_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 38usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_40(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(39usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_40(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(39usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_40_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 39usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_40_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 39usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bit_41(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 1u8) as u32) } + } + #[inline] + pub fn set_bit_41(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(40usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bit_41_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 40usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bit_41_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 16usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 40usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bit_1: ::std::os::raw::c_uint, + bit_2: ::std::os::raw::c_uint, + bit_3: ::std::os::raw::c_uint, + bit_4: ::std::os::raw::c_uint, + bit_5: ::std::os::raw::c_uint, + bit_6: ::std::os::raw::c_uint, + bit_7: ::std::os::raw::c_uint, + bit_8: ::std::os::raw::c_uint, + bit_9: ::std::os::raw::c_uint, + bit_10: ::std::os::raw::c_uint, + bit_11: ::std::os::raw::c_uint, + bit_12: ::std::os::raw::c_uint, + bit_13: ::std::os::raw::c_uint, + bit_14: ::std::os::raw::c_uint, + bit_15: ::std::os::raw::c_uint, + bit_16: ::std::os::raw::c_uint, + bit_17: ::std::os::raw::c_uint, + bit_18: ::std::os::raw::c_uint, + bit_19: ::std::os::raw::c_uint, + bit_20: ::std::os::raw::c_uint, + bit_21: ::std::os::raw::c_uint, + bit_22: ::std::os::raw::c_uint, + bit_23: ::std::os::raw::c_uint, + bit_24: ::std::os::raw::c_uint, + bit_25: ::std::os::raw::c_uint, + bit_26: ::std::os::raw::c_uint, + bit_27: ::std::os::raw::c_uint, + bit_28: ::std::os::raw::c_uint, + bit_29: ::std::os::raw::c_uint, + bit_30: ::std::os::raw::c_uint, + bit_31: ::std::os::raw::c_uint, + bit_32: ::std::os::raw::c_uint, + bit_33: ::std::os::raw::c_uint, + bit_34: ::std::os::raw::c_uint, + bit_35: ::std::os::raw::c_uint, + bit_36: ::std::os::raw::c_uint, + bit_37: ::std::os::raw::c_uint, + bit_38: ::std::os::raw::c_uint, + bit_39: ::std::os::raw::c_uint, + bit_40: ::std::os::raw::c_uint, + bit_41: ::std::os::raw::c_uint, + ) -> __BindgenBitfieldUnit<[u8; 16usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let bit_1: u32 = unsafe { ::std::mem::transmute(bit_1) }; + bit_1 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 1u8, + { + let bit_2: u32 = unsafe { ::std::mem::transmute(bit_2) }; + bit_2 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 2usize, + 1u8, + { + let bit_3: u32 = unsafe { ::std::mem::transmute(bit_3) }; + bit_3 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 3usize, + 1u8, + { + let bit_4: u32 = unsafe { ::std::mem::transmute(bit_4) }; + bit_4 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 4usize, + 1u8, + { + let bit_5: u32 = unsafe { ::std::mem::transmute(bit_5) }; + bit_5 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 5usize, + 1u8, + { + let bit_6: u32 = unsafe { ::std::mem::transmute(bit_6) }; + bit_6 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 6usize, + 1u8, + { + let bit_7: u32 = unsafe { ::std::mem::transmute(bit_7) }; + bit_7 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 7usize, + 1u8, + { + let bit_8: u32 = unsafe { ::std::mem::transmute(bit_8) }; + bit_8 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 8usize, + 1u8, + { + let bit_9: u32 = unsafe { ::std::mem::transmute(bit_9) }; + bit_9 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 9usize, + 1u8, + { + let bit_10: u32 = unsafe { ::std::mem::transmute(bit_10) }; + bit_10 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 10usize, + 1u8, + { + let bit_11: u32 = unsafe { ::std::mem::transmute(bit_11) }; + bit_11 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 11usize, + 1u8, + { + let bit_12: u32 = unsafe { ::std::mem::transmute(bit_12) }; + bit_12 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 12usize, + 1u8, + { + let bit_13: u32 = unsafe { ::std::mem::transmute(bit_13) }; + bit_13 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 13usize, + 1u8, + { + let bit_14: u32 = unsafe { ::std::mem::transmute(bit_14) }; + bit_14 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 14usize, + 1u8, + { + let bit_15: u32 = unsafe { ::std::mem::transmute(bit_15) }; + bit_15 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 15usize, + 1u8, + { + let bit_16: u32 = unsafe { ::std::mem::transmute(bit_16) }; + bit_16 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 16usize, + 1u8, + { + let bit_17: u32 = unsafe { ::std::mem::transmute(bit_17) }; + bit_17 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 17usize, + 1u8, + { + let bit_18: u32 = unsafe { ::std::mem::transmute(bit_18) }; + bit_18 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 18usize, + 1u8, + { + let bit_19: u32 = unsafe { ::std::mem::transmute(bit_19) }; + bit_19 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 19usize, + 1u8, + { + let bit_20: u32 = unsafe { ::std::mem::transmute(bit_20) }; + bit_20 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 20usize, + 1u8, + { + let bit_21: u32 = unsafe { ::std::mem::transmute(bit_21) }; + bit_21 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 21usize, + 1u8, + { + let bit_22: u32 = unsafe { ::std::mem::transmute(bit_22) }; + bit_22 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 22usize, + 1u8, + { + let bit_23: u32 = unsafe { ::std::mem::transmute(bit_23) }; + bit_23 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 23usize, + 1u8, + { + let bit_24: u32 = unsafe { ::std::mem::transmute(bit_24) }; + bit_24 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 24usize, + 1u8, + { + let bit_25: u32 = unsafe { ::std::mem::transmute(bit_25) }; + bit_25 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 25usize, + 1u8, + { + let bit_26: u32 = unsafe { ::std::mem::transmute(bit_26) }; + bit_26 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 26usize, + 1u8, + { + let bit_27: u32 = unsafe { ::std::mem::transmute(bit_27) }; + bit_27 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 27usize, + 1u8, + { + let bit_28: u32 = unsafe { ::std::mem::transmute(bit_28) }; + bit_28 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 28usize, + 1u8, + { + let bit_29: u32 = unsafe { ::std::mem::transmute(bit_29) }; + bit_29 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 29usize, + 1u8, + { + let bit_30: u32 = unsafe { ::std::mem::transmute(bit_30) }; + bit_30 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 30usize, + 1u8, + { + let bit_31: u32 = unsafe { ::std::mem::transmute(bit_31) }; + bit_31 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 31usize, + 1u8, + { + let bit_32: u32 = unsafe { ::std::mem::transmute(bit_32) }; + bit_32 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 32usize, + 1u8, + { + let bit_33: u32 = unsafe { ::std::mem::transmute(bit_33) }; + bit_33 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 33usize, + 1u8, + { + let bit_34: u32 = unsafe { ::std::mem::transmute(bit_34) }; + bit_34 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 34usize, + 1u8, + { + let bit_35: u32 = unsafe { ::std::mem::transmute(bit_35) }; + bit_35 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 35usize, + 1u8, + { + let bit_36: u32 = unsafe { ::std::mem::transmute(bit_36) }; + bit_36 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 36usize, + 1u8, + { + let bit_37: u32 = unsafe { ::std::mem::transmute(bit_37) }; + bit_37 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 37usize, + 1u8, + { + let bit_38: u32 = unsafe { ::std::mem::transmute(bit_38) }; + bit_38 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 38usize, + 1u8, + { + let bit_39: u32 = unsafe { ::std::mem::transmute(bit_39) }; + bit_39 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 39usize, + 1u8, + { + let bit_40: u32 = unsafe { ::std::mem::transmute(bit_40) }; + bit_40 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 40usize, + 1u8, + { + let bit_41: u32 = unsafe { ::std::mem::transmute(bit_41) }; + bit_41 as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-820-unused-template-param-in-alias.rs b/bindgen-tests/tests/expectations/tests/issue-820-unused-template-param-in-alias.rs new file mode 100644 index 0000000000..a367e2e0e1 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-820-unused-template-param-in-alias.rs @@ -0,0 +1,2 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type Foo_self_type = u8; diff --git a/bindgen-tests/tests/expectations/tests/issue-826-generating-methods-when-asked-not-to.rs b/bindgen-tests/tests/expectations/tests/issue-826-generating-methods-when-asked-not-to.rs new file mode 100644 index 0000000000..551dff82cf --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-826-generating-methods-when-asked-not-to.rs @@ -0,0 +1,11 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/issue-833-1.rs b/bindgen-tests/tests/expectations/tests/issue-833-1.rs new file mode 100644 index 0000000000..5aa8c3078b --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-833-1.rs @@ -0,0 +1,8 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct nsTArray { + pub hdr: *const (), +} +unsafe extern "C" { + pub fn func() -> *mut nsTArray; +} diff --git a/bindgen-tests/tests/expectations/tests/issue-833-2.rs b/bindgen-tests/tests/expectations/tests/issue-833-2.rs new file mode 100644 index 0000000000..b8ef2f8554 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-833-2.rs @@ -0,0 +1,6 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct nsTArray { + pub _address: u8, +} diff --git a/bindgen-tests/tests/expectations/tests/issue-833.rs b/bindgen-tests/tests/expectations/tests/issue-833.rs new file mode 100644 index 0000000000..9698fdb479 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-833.rs @@ -0,0 +1,8 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct nsTArray { + pub hdr: *const T, +} +unsafe extern "C" { + pub fn func() -> *mut nsTArray<::std::os::raw::c_int>; +} diff --git a/bindgen-tests/tests/expectations/tests/issue-834.rs b/bindgen-tests/tests/expectations/tests/issue-834.rs new file mode 100644 index 0000000000..4119a450e0 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-834.rs @@ -0,0 +1,11 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct U { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of U"][::std::mem::size_of::() - 1usize]; + ["Alignment of U"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/issue-848-replacement-system-include.rs b/bindgen-tests/tests/expectations/tests/issue-848-replacement-system-include.rs new file mode 100644 index 0000000000..6beeae69d8 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-848-replacement-system-include.rs @@ -0,0 +1,25 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +/** This is intended to replace another type, but won't if we treat this include + as a system include, because clang doesn't parse comments there. + + See #848. + +
*/ +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nsTArray { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub m: *mut T, +} +impl Default for nsTArray { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +unsafe extern "C" { + pub fn func() -> *mut nsTArray<::std::os::raw::c_int>; +} diff --git a/bindgen-tests/tests/expectations/tests/issue-888-enum-var-decl-jump.rs b/bindgen-tests/tests/expectations/tests/issue-888-enum-var-decl-jump.rs new file mode 100644 index 0000000000..023c8695e3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-888-enum-var-decl-jump.rs @@ -0,0 +1,29 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod Halide { + #[allow(unused_imports)] + use self::super::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Type { + pub _address: u8, + } + unsafe extern "C" { + #[link_name = "\u{1}_ZN6Halide4Type1bE"] + pub static mut Type_b: root::a; + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Type"][::std::mem::size_of::() - 1usize]; + ["Alignment of Type"][::std::mem::align_of::() - 1usize]; + }; + } + #[repr(u32)] + #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] + pub enum a { + __bindgen_cannot_repr_c_on_empty_enum = 0, + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-944-derive-copy-and-blocklisting.rs b/bindgen-tests/tests/expectations/tests/issue-944-derive-copy-and-blocklisting.rs new file mode 100644 index 0000000000..5e8dde04e3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-944-derive-copy-and-blocklisting.rs @@ -0,0 +1,24 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub struct BlocklistMe(u8); +/// Because this type contains a blocklisted type, it should not derive Copy. +#[repr(C)] +pub struct ShouldNotBeCopy { + pub a: BlocklistMe, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ShouldNotBeCopy"][::std::mem::size_of::() - 1usize]; + ["Alignment of ShouldNotBeCopy"][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: ShouldNotBeCopy::a", + ][::std::mem::offset_of!(ShouldNotBeCopy, a) - 0usize]; +}; +impl Default for ShouldNotBeCopy { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/issue-946.rs b/bindgen-tests/tests/expectations/tests/issue-946.rs new file mode 100644 index 0000000000..bdd56c0326 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue-946.rs @@ -0,0 +1,10 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct foo {} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 0usize]; + ["Alignment of foo"][::std::mem::align_of::() - 1usize]; +}; +pub type bar = foo; diff --git a/bindgen-tests/tests/expectations/tests/issue_311.rs b/bindgen-tests/tests/expectations/tests/issue_311.rs new file mode 100644 index 0000000000..2e0114e43e --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue_311.rs @@ -0,0 +1,30 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct jsval_layout { + pub __bindgen_anon_1: root::jsval_layout__bindgen_ty_1, + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct jsval_layout__bindgen_ty_1 { + pub _address: u8, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + [ + "Size of jsval_layout__bindgen_ty_1", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of jsval_layout__bindgen_ty_1", + ][::std::mem::align_of::() - 1usize]; + }; + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of jsval_layout"][::std::mem::size_of::() - 1usize]; + ["Alignment of jsval_layout"][::std::mem::align_of::() - 1usize]; + }; +} diff --git a/bindgen-tests/tests/expectations/tests/issue_315.rs b/bindgen-tests/tests/expectations/tests/issue_315.rs new file mode 100644 index 0000000000..cecdccc2aa --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/issue_315.rs @@ -0,0 +1,3 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +///
+pub type c = a; diff --git a/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs new file mode 100644 index 0000000000..dc0ef8ed7f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs @@ -0,0 +1,483 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +pub const JSVAL_TAG_SHIFT: u32 = 47; +pub const JSVAL_PAYLOAD_MASK: u64 = 140737488355327; +pub const JSVAL_TAG_MASK: i64 = -140737488355328; +#[repr(u8)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum JSValueType { + JSVAL_TYPE_DOUBLE = 0, + JSVAL_TYPE_INT32 = 1, + JSVAL_TYPE_UNDEFINED = 2, + JSVAL_TYPE_BOOLEAN = 3, + JSVAL_TYPE_MAGIC = 4, + JSVAL_TYPE_STRING = 5, + JSVAL_TYPE_SYMBOL = 6, + JSVAL_TYPE_NULL = 7, + JSVAL_TYPE_OBJECT = 8, + JSVAL_TYPE_UNKNOWN = 32, + JSVAL_TYPE_MISSING = 33, +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum JSValueTag { + JSVAL_TAG_MAX_DOUBLE = 131056, + JSVAL_TAG_INT32 = 131057, + JSVAL_TAG_UNDEFINED = 131058, + JSVAL_TAG_STRING = 131061, + JSVAL_TAG_SYMBOL = 131062, + JSVAL_TAG_BOOLEAN = 131059, + JSVAL_TAG_MAGIC = 131060, + JSVAL_TAG_NULL = 131063, + JSVAL_TAG_OBJECT = 131064, +} +#[repr(u64)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum JSValueShiftedTag { + JSVAL_SHIFTED_TAG_MAX_DOUBLE = 18444492278190833663, + JSVAL_SHIFTED_TAG_INT32 = 18444633011384221696, + JSVAL_SHIFTED_TAG_UNDEFINED = 18444773748872577024, + JSVAL_SHIFTED_TAG_STRING = 18445195961337643008, + JSVAL_SHIFTED_TAG_SYMBOL = 18445336698825998336, + JSVAL_SHIFTED_TAG_BOOLEAN = 18444914486360932352, + JSVAL_SHIFTED_TAG_MAGIC = 18445055223849287680, + JSVAL_SHIFTED_TAG_NULL = 18445477436314353664, + JSVAL_SHIFTED_TAG_OBJECT = 18445618173802708992, +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum JSWhyMagic { + /// a hole in a native object's elements + JS_ELEMENTS_HOLE = 0, + /// there is not a pending iterator value + JS_NO_ITER_VALUE = 1, + /// exception value thrown when closing a generator + JS_GENERATOR_CLOSING = 2, + /// compiler sentinel value + JS_NO_CONSTANT = 3, + /// used in debug builds to catch tracing errors + JS_THIS_POISON = 4, + /// used in debug builds to catch tracing errors + JS_ARG_POISON = 5, + /// an empty subnode in the AST serializer + JS_SERIALIZE_NO_NODE = 6, + /// lazy arguments value on the stack + JS_LAZY_ARGUMENTS = 7, + /// optimized-away 'arguments' value + JS_OPTIMIZED_ARGUMENTS = 8, + /// magic value passed to natives to indicate construction + JS_IS_CONSTRUCTING = 9, + /// arguments.callee has been overwritten + JS_OVERWRITTEN_CALLEE = 10, + /// value of static block object slot + JS_BLOCK_NEEDS_CLONE = 11, + /// see class js::HashableValue + JS_HASH_KEY_EMPTY = 12, + /// error while running Ion code + JS_ION_ERROR = 13, + /// missing recover instruction result + JS_ION_BAILOUT = 14, + /// optimized out slot + JS_OPTIMIZED_OUT = 15, + /// uninitialized lexical bindings that produce ReferenceError on touch. + JS_UNINITIALIZED_LEXICAL = 16, + /// for local use + JS_GENERIC_MAGIC = 17, + /// for local use + JS_WHY_MAGIC_COUNT = 18, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union jsval_layout { + pub asBits: u64, + pub debugView: jsval_layout__bindgen_ty_1, + pub s: jsval_layout__bindgen_ty_2, + pub asDouble: f64, + pub asPtr: *mut ::std::os::raw::c_void, + pub asWord: usize, + pub asUIntPtr: usize, +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct jsval_layout__bindgen_ty_1 { + pub _bindgen_align: [u64; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of jsval_layout__bindgen_ty_1", + ][::std::mem::size_of::() - 8usize]; + [ + "Alignment of jsval_layout__bindgen_ty_1", + ][::std::mem::align_of::() - 8usize]; +}; +impl Default for jsval_layout__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl jsval_layout__bindgen_ty_1 { + #[inline] + pub fn payload47(&self) -> u64 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 47u8) as u64) } + } + #[inline] + pub fn set_payload47(&mut self, val: u64) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 47u8, val as u64) + } + } + #[inline] + pub unsafe fn payload47_raw(this: *const Self) -> u64 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 8usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 47u8) + as u64, + ) + } + } + #[inline] + pub unsafe fn set_payload47_raw(this: *mut Self, val: u64) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 8usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 47u8, + val as u64, + ) + } + } + #[inline] + pub fn tag(&self) -> JSValueTag { + unsafe { ::std::mem::transmute(self._bitfield_1.get(47usize, 17u8) as u32) } + } + #[inline] + pub fn set_tag(&mut self, val: JSValueTag) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(47usize, 17u8, val as u64) + } + } + #[inline] + pub unsafe fn tag_raw(this: *const Self) -> JSValueTag { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 8usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 47usize, 17u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_tag_raw(this: *mut Self, val: JSValueTag) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 8usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 47usize, + 17u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + payload47: u64, + tag: JSValueTag, + ) -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 47u8, + { + let payload47: u64 = unsafe { ::std::mem::transmute(payload47) }; + payload47 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 47usize, + 17u8, + { + let tag: u32 = unsafe { ::std::mem::transmute(tag) }; + tag as u64 + }, + ); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct jsval_layout__bindgen_ty_2 { + pub payload: jsval_layout__bindgen_ty_2__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union jsval_layout__bindgen_ty_2__bindgen_ty_1 { + pub i32_: i32, + pub u32_: u32, + pub why: JSWhyMagic, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of jsval_layout__bindgen_ty_2__bindgen_ty_1", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of jsval_layout__bindgen_ty_2__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: jsval_layout__bindgen_ty_2__bindgen_ty_1::i32_", + ][::std::mem::offset_of!(jsval_layout__bindgen_ty_2__bindgen_ty_1, i32_) - 0usize]; + [ + "Offset of field: jsval_layout__bindgen_ty_2__bindgen_ty_1::u32_", + ][::std::mem::offset_of!(jsval_layout__bindgen_ty_2__bindgen_ty_1, u32_) - 0usize]; + [ + "Offset of field: jsval_layout__bindgen_ty_2__bindgen_ty_1::why", + ][::std::mem::offset_of!(jsval_layout__bindgen_ty_2__bindgen_ty_1, why) - 0usize]; +}; +impl Default for jsval_layout__bindgen_ty_2__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of jsval_layout__bindgen_ty_2", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of jsval_layout__bindgen_ty_2", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: jsval_layout__bindgen_ty_2::payload", + ][::std::mem::offset_of!(jsval_layout__bindgen_ty_2, payload) - 0usize]; +}; +impl Default for jsval_layout__bindgen_ty_2 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of jsval_layout"][::std::mem::size_of::() - 8usize]; + ["Alignment of jsval_layout"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: jsval_layout::asBits", + ][::std::mem::offset_of!(jsval_layout, asBits) - 0usize]; + [ + "Offset of field: jsval_layout::debugView", + ][::std::mem::offset_of!(jsval_layout, debugView) - 0usize]; + [ + "Offset of field: jsval_layout::s", + ][::std::mem::offset_of!(jsval_layout, s) - 0usize]; + [ + "Offset of field: jsval_layout::asDouble", + ][::std::mem::offset_of!(jsval_layout, asDouble) - 0usize]; + [ + "Offset of field: jsval_layout::asPtr", + ][::std::mem::offset_of!(jsval_layout, asPtr) - 0usize]; + [ + "Offset of field: jsval_layout::asWord", + ][::std::mem::offset_of!(jsval_layout, asWord) - 0usize]; + [ + "Offset of field: jsval_layout::asUIntPtr", + ][::std::mem::offset_of!(jsval_layout, asUIntPtr) - 0usize]; +}; +impl Default for jsval_layout { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Value { + pub data: jsval_layout, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Value"][::std::mem::size_of::() - 8usize]; + ["Alignment of Value"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Value::data"][::std::mem::offset_of!(Value, data) - 0usize]; +}; +impl Default for Value { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/keywords.rs b/bindgen-tests/tests/expectations/tests/keywords.rs new file mode 100644 index 0000000000..0a55ee0463 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/keywords.rs @@ -0,0 +1,225 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + #[link_name = "\u{1}u8"] + pub static mut u8_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}u16"] + pub static mut u16_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}u32"] + pub static mut u32_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}u64"] + pub static mut u64_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}i8"] + pub static mut i8_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}i16"] + pub static mut i16_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}i32"] + pub static mut i32_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}i64"] + pub static mut i64_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}f32"] + pub static mut f32_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}f64"] + pub static mut f64_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}usize"] + pub static mut usize_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}isize"] + pub static mut isize_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}bool"] + pub static mut bool_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}str"] + pub static mut str_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}dyn"] + pub static mut dyn_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}as"] + pub static mut as_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}async"] + pub static mut async_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}await"] + pub static mut await_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}box"] + pub static mut box_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}crate"] + pub static mut crate_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}false"] + pub static mut false_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}fn"] + pub static mut fn_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}gen"] + pub static mut gen_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}impl"] + pub static mut impl_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}in"] + pub static mut in_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}let"] + pub static mut let_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}loop"] + pub static mut loop_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}match"] + pub static mut match_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}mod"] + pub static mut mod_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}move"] + pub static mut move_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}mut"] + pub static mut mut_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}pub"] + pub static mut pub_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}ref"] + pub static mut ref_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}self"] + pub static mut self_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}Self"] + pub static mut Self_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}super"] + pub static mut super_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}trait"] + pub static mut trait_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}true"] + pub static mut true_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}try"] + pub static mut try_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}type"] + pub static mut type_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}unsafe"] + pub static mut unsafe_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}use"] + pub static mut use_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}where"] + pub static mut where_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}abstract"] + pub static mut abstract_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}alignof"] + pub static mut alignof_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}become"] + pub static mut become_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}final"] + pub static mut final_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}macro"] + pub static mut macro_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}offsetof"] + pub static mut offsetof_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}override"] + pub static mut override_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}priv"] + pub static mut priv_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}proc"] + pub static mut proc_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}pure"] + pub static mut pure_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}unsized"] + pub static mut unsized_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}virtual"] + pub static mut virtual_: ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}yield"] + pub static mut yield_: ::std::os::raw::c_int; +} diff --git a/bindgen-tests/tests/expectations/tests/layout.rs b/bindgen-tests/tests/expectations/tests/layout.rs new file mode 100644 index 0000000000..fe64295a68 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/layout.rs @@ -0,0 +1 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] \ No newline at end of file diff --git a/bindgen-tests/tests/expectations/tests/layout_align.rs b/bindgen-tests/tests/expectations/tests/layout_align.rs new file mode 100644 index 0000000000..a942adb8f2 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/layout_align.rs @@ -0,0 +1,385 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Default)] +pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); +impl __IncompleteArrayField { + #[inline] + pub const fn new() -> Self { + __IncompleteArrayField(::std::marker::PhantomData, []) + } + #[inline] + pub fn as_ptr(&self) -> *const T { + self as *const _ as *const T + } + #[inline] + pub fn as_mut_ptr(&mut self) -> *mut T { + self as *mut _ as *mut T + } + #[inline] + pub unsafe fn as_slice(&self, len: usize) -> &[T] { + ::std::slice::from_raw_parts(self.as_ptr(), len) + } + #[inline] + pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { + ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) + } +} +impl ::std::fmt::Debug for __IncompleteArrayField { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + fmt.write_str("__IncompleteArrayField") + } +} +#[repr(C)] +#[derive(Debug)] +pub struct rte_kni_fifo { + ///< Next position to be written + pub write: ::std::os::raw::c_uint, + ///< Next position to be read + pub read: ::std::os::raw::c_uint, + ///< Circular buffer length + pub len: ::std::os::raw::c_uint, + ///< Pointer size - for 32/64 bit OS + pub elem_size: ::std::os::raw::c_uint, + ///< The buffer contains mbuf pointers + pub buffer: __IncompleteArrayField<*mut ::std::os::raw::c_void>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_kni_fifo"][::std::mem::size_of::() - 16usize]; + ["Alignment of rte_kni_fifo"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: rte_kni_fifo::write", + ][::std::mem::offset_of!(rte_kni_fifo, write) - 0usize]; + [ + "Offset of field: rte_kni_fifo::read", + ][::std::mem::offset_of!(rte_kni_fifo, read) - 4usize]; + [ + "Offset of field: rte_kni_fifo::len", + ][::std::mem::offset_of!(rte_kni_fifo, len) - 8usize]; + [ + "Offset of field: rte_kni_fifo::elem_size", + ][::std::mem::offset_of!(rte_kni_fifo, elem_size) - 12usize]; + [ + "Offset of field: rte_kni_fifo::buffer", + ][::std::mem::offset_of!(rte_kni_fifo, buffer) - 16usize]; +}; +impl Default for rte_kni_fifo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct rte_eth_link { + pub _bindgen_align: [u64; 0], + ///< ETH_SPEED_NUM_ + pub link_speed: u32, + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_eth_link"][::std::mem::size_of::() - 8usize]; + ["Alignment of rte_eth_link"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: rte_eth_link::link_speed", + ][::std::mem::offset_of!(rte_eth_link, link_speed) - 0usize]; +}; +impl rte_eth_link { + #[inline] + pub fn link_duplex(&self) -> u16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) } + } + #[inline] + pub fn set_link_duplex(&mut self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn link_duplex_raw(this: *const Self) -> u16 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_link_duplex_raw(this: *mut Self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn link_autoneg(&self) -> u16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16) } + } + #[inline] + pub fn set_link_autoneg(&mut self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn link_autoneg_raw(this: *const Self) -> u16 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_link_autoneg_raw(this: *mut Self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn link_status(&self) -> u16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16) } + } + #[inline] + pub fn set_link_status(&mut self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn link_status_raw(this: *const Self) -> u16 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_link_status_raw(this: *mut Self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + link_duplex: u16, + link_autoneg: u16, + link_status: u16, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let link_duplex: u16 = unsafe { ::std::mem::transmute(link_duplex) }; + link_duplex as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 1u8, + { + let link_autoneg: u16 = unsafe { + ::std::mem::transmute(link_autoneg) + }; + link_autoneg as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 2usize, + 1u8, + { + let link_status: u16 = unsafe { ::std::mem::transmute(link_status) }; + link_status as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/layout_arp.rs b/bindgen-tests/tests/expectations/tests/layout_arp.rs new file mode 100644 index 0000000000..c94dc2ce24 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/layout_arp.rs @@ -0,0 +1,96 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const ETHER_ADDR_LEN: u32 = 6; +pub const ARP_HRD_ETHER: u32 = 1; +pub const ARP_OP_REQUEST: u32 = 1; +pub const ARP_OP_REPLY: u32 = 2; +pub const ARP_OP_REVREQUEST: u32 = 3; +pub const ARP_OP_REVREPLY: u32 = 4; +pub const ARP_OP_INVREQUEST: u32 = 8; +pub const ARP_OP_INVREPLY: u32 = 9; +/** Ethernet address: + A universally administered address is uniquely assigned to a device by its + manufacturer. The first three octets (in transmission order) contain the + Organizationally Unique Identifier (OUI). The following three (MAC-48 and + EUI-48) octets are assigned by that organization with the only constraint + of uniqueness. + A locally administered address is assigned to a device by a network + administrator and does not contain OUIs. + See http://standards.ieee.org/regauth/groupmac/tutorial.html*/ +#[repr(C, packed)] +#[derive(Debug, Default, Copy, Clone)] +pub struct ether_addr { + ///< Addr bytes in tx order + pub addr_bytes: [u8; 6usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ether_addr"][::std::mem::size_of::() - 6usize]; + ["Alignment of ether_addr"][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: ether_addr::addr_bytes", + ][::std::mem::offset_of!(ether_addr, addr_bytes) - 0usize]; +}; +/// ARP header IPv4 payload. +#[repr(C, packed)] +#[derive(Debug, Default, Copy, Clone)] +pub struct arp_ipv4 { + ///< sender hardware address + pub arp_sha: ether_addr, + ///< sender IP address + pub arp_sip: u32, + ///< target hardware address + pub arp_tha: ether_addr, + ///< target IP address + pub arp_tip: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of arp_ipv4"][::std::mem::size_of::() - 20usize]; + ["Alignment of arp_ipv4"][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: arp_ipv4::arp_sha", + ][::std::mem::offset_of!(arp_ipv4, arp_sha) - 0usize]; + [ + "Offset of field: arp_ipv4::arp_sip", + ][::std::mem::offset_of!(arp_ipv4, arp_sip) - 6usize]; + [ + "Offset of field: arp_ipv4::arp_tha", + ][::std::mem::offset_of!(arp_ipv4, arp_tha) - 10usize]; + [ + "Offset of field: arp_ipv4::arp_tip", + ][::std::mem::offset_of!(arp_ipv4, arp_tip) - 16usize]; +}; +/// ARP header. +#[repr(C, packed)] +#[derive(Debug, Default, Copy, Clone)] +pub struct arp_hdr { + pub arp_hrd: u16, + pub arp_pro: u16, + pub arp_hln: u8, + pub arp_pln: u8, + pub arp_op: u16, + pub arp_data: arp_ipv4, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of arp_hdr"][::std::mem::size_of::() - 28usize]; + ["Alignment of arp_hdr"][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: arp_hdr::arp_hrd", + ][::std::mem::offset_of!(arp_hdr, arp_hrd) - 0usize]; + [ + "Offset of field: arp_hdr::arp_pro", + ][::std::mem::offset_of!(arp_hdr, arp_pro) - 2usize]; + [ + "Offset of field: arp_hdr::arp_hln", + ][::std::mem::offset_of!(arp_hdr, arp_hln) - 4usize]; + [ + "Offset of field: arp_hdr::arp_pln", + ][::std::mem::offset_of!(arp_hdr, arp_pln) - 5usize]; + [ + "Offset of field: arp_hdr::arp_op", + ][::std::mem::offset_of!(arp_hdr, arp_op) - 6usize]; + [ + "Offset of field: arp_hdr::arp_data", + ][::std::mem::offset_of!(arp_hdr, arp_data) - 8usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/layout_array.rs b/bindgen-tests/tests/expectations/tests/layout_array.rs new file mode 100644 index 0000000000..3afe1c2dd8 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/layout_array.rs @@ -0,0 +1,233 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)] +#[repr(C, align(8))] +pub struct __BindgenOpaqueArray8(pub T); +impl Default for __BindgenOpaqueArray8<[T; N]> { + fn default() -> Self { + Self([::default(); N]) + } +} +pub const RTE_CACHE_LINE_SIZE: u32 = 64; +pub const RTE_MEMPOOL_OPS_NAMESIZE: u32 = 32; +pub const RTE_MEMPOOL_MAX_OPS_IDX: u32 = 16; +pub const RTE_HEAP_NUM_FREELISTS: u32 = 13; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct rte_mempool { + _unused: [u8; 0], +} +/** Prototype for implementation specific data provisioning function. + + The function should provide the implementation specific memory for + for use by the other mempool ops functions in a given mempool ops struct. + E.g. the default ops provides an instance of the rte_ring for this purpose. + it will most likely point to a different type of data structure, and + will be transparent to the application programmer. + This function should set mp->pool_data.*/ +pub type rte_mempool_alloc_t = ::std::option::Option< + unsafe extern "C" fn(mp: *mut rte_mempool) -> ::std::os::raw::c_int, +>; +/// Free the opaque private data pointed to by mp->pool_data pointer. +pub type rte_mempool_free_t = ::std::option::Option< + unsafe extern "C" fn(mp: *mut rte_mempool), +>; +/// Enqueue an object into the external pool. +pub type rte_mempool_enqueue_t = ::std::option::Option< + unsafe extern "C" fn( + mp: *mut rte_mempool, + obj_table: *const *mut ::std::os::raw::c_void, + n: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int, +>; +/// Dequeue an object from the external pool. +pub type rte_mempool_dequeue_t = ::std::option::Option< + unsafe extern "C" fn( + mp: *mut rte_mempool, + obj_table: *mut *mut ::std::os::raw::c_void, + n: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int, +>; +/// Return the number of available objects in the external pool. +pub type rte_mempool_get_count = ::std::option::Option< + unsafe extern "C" fn(mp: *const rte_mempool) -> ::std::os::raw::c_uint, +>; +/// Structure defining mempool operations structure +#[repr(C)] +#[repr(align(64))] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_mempool_ops { + ///< Name of mempool ops struct. + pub name: [::std::os::raw::c_char; 32usize], + ///< Allocate private data. + pub alloc: rte_mempool_alloc_t, + ///< Free the external pool. + pub free: rte_mempool_free_t, + ///< Enqueue an object. + pub enqueue: rte_mempool_enqueue_t, + ///< Dequeue an object. + pub dequeue: rte_mempool_dequeue_t, + ///< Get qty of available objs. + pub get_count: rte_mempool_get_count, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_mempool_ops"][::std::mem::size_of::() - 128usize]; + [ + "Alignment of rte_mempool_ops", + ][::std::mem::align_of::() - 64usize]; + [ + "Offset of field: rte_mempool_ops::name", + ][::std::mem::offset_of!(rte_mempool_ops, name) - 0usize]; + [ + "Offset of field: rte_mempool_ops::alloc", + ][::std::mem::offset_of!(rte_mempool_ops, alloc) - 32usize]; + [ + "Offset of field: rte_mempool_ops::free", + ][::std::mem::offset_of!(rte_mempool_ops, free) - 40usize]; + [ + "Offset of field: rte_mempool_ops::enqueue", + ][::std::mem::offset_of!(rte_mempool_ops, enqueue) - 48usize]; + [ + "Offset of field: rte_mempool_ops::dequeue", + ][::std::mem::offset_of!(rte_mempool_ops, dequeue) - 56usize]; + [ + "Offset of field: rte_mempool_ops::get_count", + ][::std::mem::offset_of!(rte_mempool_ops, get_count) - 64usize]; +}; +impl Default for rte_mempool_ops { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +/// The rte_spinlock_t type. +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_spinlock_t { + ///< lock status 0 = unlocked, 1 = locked + pub locked: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_spinlock_t"][::std::mem::size_of::() - 4usize]; + ["Alignment of rte_spinlock_t"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_spinlock_t::locked", + ][::std::mem::offset_of!(rte_spinlock_t, locked) - 0usize]; +}; +/** Structure storing the table of registered ops structs, each of which contain + the function pointers for the mempool ops functions. + Each process has its own storage for this ops struct array so that + the mempools can be shared across primary and secondary processes. + The indices used to access the array are valid across processes, whereas + any function pointers stored directly in the mempool struct would not be. + This results in us simply having "ops_index" in the mempool struct.*/ +#[repr(C)] +#[repr(align(64))] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_mempool_ops_table { + ///< Spinlock for add/delete. + pub sl: rte_spinlock_t, + ///< Number of used ops structs in the table. + pub num_ops: u32, + pub __bindgen_padding_0: __BindgenOpaqueArray8<[u8; 56usize]>, + /// Storage for all possible ops structs. + pub ops: [rte_mempool_ops; 16usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_mempool_ops_table", + ][::std::mem::size_of::() - 2112usize]; + [ + "Alignment of rte_mempool_ops_table", + ][::std::mem::align_of::() - 64usize]; + [ + "Offset of field: rte_mempool_ops_table::sl", + ][::std::mem::offset_of!(rte_mempool_ops_table, sl) - 0usize]; + [ + "Offset of field: rte_mempool_ops_table::num_ops", + ][::std::mem::offset_of!(rte_mempool_ops_table, num_ops) - 4usize]; + [ + "Offset of field: rte_mempool_ops_table::ops", + ][::std::mem::offset_of!(rte_mempool_ops_table, ops) - 64usize]; +}; +impl Default for rte_mempool_ops_table { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +/// Structure to hold malloc heap +#[repr(C)] +#[repr(align(64))] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct malloc_heap { + pub lock: rte_spinlock_t, + pub free_head: [malloc_heap__bindgen_ty_1; 13usize], + pub alloc_count: ::std::os::raw::c_uint, + pub total_size: usize, +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct malloc_heap__bindgen_ty_1 { + pub lh_first: *mut malloc_elem, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of malloc_heap__bindgen_ty_1", + ][::std::mem::size_of::() - 8usize]; + [ + "Alignment of malloc_heap__bindgen_ty_1", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: malloc_heap__bindgen_ty_1::lh_first", + ][::std::mem::offset_of!(malloc_heap__bindgen_ty_1, lh_first) - 0usize]; +}; +impl Default for malloc_heap__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of malloc_heap"][::std::mem::size_of::() - 128usize]; + ["Alignment of malloc_heap"][::std::mem::align_of::() - 64usize]; + [ + "Offset of field: malloc_heap::lock", + ][::std::mem::offset_of!(malloc_heap, lock) - 0usize]; + [ + "Offset of field: malloc_heap::free_head", + ][::std::mem::offset_of!(malloc_heap, free_head) - 8usize]; + [ + "Offset of field: malloc_heap::alloc_count", + ][::std::mem::offset_of!(malloc_heap, alloc_count) - 112usize]; + [ + "Offset of field: malloc_heap::total_size", + ][::std::mem::offset_of!(malloc_heap, total_size) - 120usize]; +}; +impl Default for malloc_heap { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct malloc_elem { + pub _address: u8, +} diff --git a/bindgen-tests/tests/expectations/tests/layout_array_too_long.rs b/bindgen-tests/tests/expectations/tests/layout_array_too_long.rs new file mode 100644 index 0000000000..315663e0fc --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/layout_array_too_long.rs @@ -0,0 +1,163 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const RTE_CACHE_LINE_SIZE: u32 = 64; +pub const RTE_LIBRTE_IP_FRAG_MAX_FRAG: u32 = 4; +pub const IP_LAST_FRAG_IDX: _bindgen_ty_1 = _bindgen_ty_1::IP_LAST_FRAG_IDX; +pub const IP_FIRST_FRAG_IDX: _bindgen_ty_1 = _bindgen_ty_1::IP_FIRST_FRAG_IDX; +pub const IP_MIN_FRAG_NUM: _bindgen_ty_1 = _bindgen_ty_1::IP_MIN_FRAG_NUM; +pub const IP_MAX_FRAG_NUM: _bindgen_ty_1 = _bindgen_ty_1::IP_MAX_FRAG_NUM; +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _bindgen_ty_1 { + ///< index of last fragment + IP_LAST_FRAG_IDX = 0, + ///< index of first fragment + IP_FIRST_FRAG_IDX = 1, + ///< minimum number of fragments + IP_MIN_FRAG_NUM = 2, + IP_MAX_FRAG_NUM = 4, +} +/// @internal fragmented mbuf +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct ip_frag { + ///< offset into the packet + pub ofs: u16, + ///< length of fragment + pub len: u16, + ///< fragment mbuf + pub mb: *mut rte_mbuf, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ip_frag"][::std::mem::size_of::() - 16usize]; + ["Alignment of ip_frag"][::std::mem::align_of::() - 8usize]; + ["Offset of field: ip_frag::ofs"][::std::mem::offset_of!(ip_frag, ofs) - 0usize]; + ["Offset of field: ip_frag::len"][::std::mem::offset_of!(ip_frag, len) - 2usize]; + ["Offset of field: ip_frag::mb"][::std::mem::offset_of!(ip_frag, mb) - 8usize]; +}; +impl Default for ip_frag { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +/// @internal to uniquely indetify fragmented datagram. +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct ip_frag_key { + ///< src address, first 8 bytes used for IPv4 + pub src_dst: [u64; 4usize], + ///< dst address + pub id: u32, + ///< src/dst key length + pub key_len: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ip_frag_key"][::std::mem::size_of::() - 40usize]; + ["Alignment of ip_frag_key"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: ip_frag_key::src_dst", + ][::std::mem::offset_of!(ip_frag_key, src_dst) - 0usize]; + [ + "Offset of field: ip_frag_key::id", + ][::std::mem::offset_of!(ip_frag_key, id) - 32usize]; + [ + "Offset of field: ip_frag_key::key_len", + ][::std::mem::offset_of!(ip_frag_key, key_len) - 36usize]; +}; +/** @internal Fragmented packet to reassemble. + First two entries in the frags[] array are for the last and first fragments.*/ +#[repr(C)] +#[repr(align(64))] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct ip_frag_pkt { + ///< LRU list + pub lru: ip_frag_pkt__bindgen_ty_1, + ///< fragmentation key + pub key: ip_frag_key, + ///< creation timestamp + pub start: u64, + ///< expected reassembled size + pub total_size: u32, + ///< size of fragments received + pub frag_size: u32, + ///< index of next entry to fill + pub last_idx: u32, + ///< fragments + pub frags: [ip_frag; 4usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct ip_frag_pkt__bindgen_ty_1 { + pub tqe_next: *mut ip_frag_pkt, + pub tqe_prev: *mut *mut ip_frag_pkt, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of ip_frag_pkt__bindgen_ty_1", + ][::std::mem::size_of::() - 16usize]; + [ + "Alignment of ip_frag_pkt__bindgen_ty_1", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: ip_frag_pkt__bindgen_ty_1::tqe_next", + ][::std::mem::offset_of!(ip_frag_pkt__bindgen_ty_1, tqe_next) - 0usize]; + [ + "Offset of field: ip_frag_pkt__bindgen_ty_1::tqe_prev", + ][::std::mem::offset_of!(ip_frag_pkt__bindgen_ty_1, tqe_prev) - 8usize]; +}; +impl Default for ip_frag_pkt__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ip_frag_pkt"][::std::mem::size_of::() - 192usize]; + ["Alignment of ip_frag_pkt"][::std::mem::align_of::() - 64usize]; + [ + "Offset of field: ip_frag_pkt::lru", + ][::std::mem::offset_of!(ip_frag_pkt, lru) - 0usize]; + [ + "Offset of field: ip_frag_pkt::key", + ][::std::mem::offset_of!(ip_frag_pkt, key) - 16usize]; + [ + "Offset of field: ip_frag_pkt::start", + ][::std::mem::offset_of!(ip_frag_pkt, start) - 56usize]; + [ + "Offset of field: ip_frag_pkt::total_size", + ][::std::mem::offset_of!(ip_frag_pkt, total_size) - 64usize]; + [ + "Offset of field: ip_frag_pkt::frag_size", + ][::std::mem::offset_of!(ip_frag_pkt, frag_size) - 68usize]; + [ + "Offset of field: ip_frag_pkt::last_idx", + ][::std::mem::offset_of!(ip_frag_pkt, last_idx) - 72usize]; + [ + "Offset of field: ip_frag_pkt::frags", + ][::std::mem::offset_of!(ip_frag_pkt, frags) - 80usize]; +}; +impl Default for ip_frag_pkt { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +///< fragment mbuf +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_mbuf { + pub _address: u8, +} diff --git a/bindgen-tests/tests/expectations/tests/layout_cmdline_token.rs b/bindgen-tests/tests/expectations/tests/layout_cmdline_token.rs new file mode 100644 index 0000000000..fb7b3bf584 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/layout_cmdline_token.rs @@ -0,0 +1,173 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +/** Stores a pointer to the ops struct, and the offset: the place to + write the parsed result in the destination structure.*/ +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct cmdline_token_hdr { + pub ops: *mut cmdline_token_ops, + pub offset: ::std::os::raw::c_uint, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of cmdline_token_hdr"][::std::mem::size_of::() - 16usize]; + [ + "Alignment of cmdline_token_hdr", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: cmdline_token_hdr::ops", + ][::std::mem::offset_of!(cmdline_token_hdr, ops) - 0usize]; + [ + "Offset of field: cmdline_token_hdr::offset", + ][::std::mem::offset_of!(cmdline_token_hdr, offset) - 8usize]; +}; +impl Default for cmdline_token_hdr { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +/** Stores a pointer to the ops struct, and the offset: the place to + write the parsed result in the destination structure.*/ +pub type cmdline_parse_token_hdr_t = cmdline_token_hdr; +/** A token is defined by this structure. + + parse() takes the token as first argument, then the source buffer + starting at the token we want to parse. The 3rd arg is a pointer + where we store the parsed data (as binary). It returns the number of + parsed chars on success and a negative value on error. + + complete_get_nb() returns the number of possible values for this + token if completion is possible. If it is NULL or if it returns 0, + no completion is possible. + + complete_get_elt() copy in dstbuf (the size is specified in the + parameter) the i-th possible completion for this token. returns 0 + on success or and a negative value on error. + + get_help() fills the dstbuf with the help for the token. It returns + -1 on error and 0 on success.*/ +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct cmdline_token_ops { + /// parse(token ptr, buf, res pts, buf len) + pub parse: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut cmdline_parse_token_hdr_t, + arg2: *const ::std::os::raw::c_char, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int, + >, + /// return the num of possible choices for this token + pub complete_get_nb: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut cmdline_parse_token_hdr_t, + ) -> ::std::os::raw::c_int, + >, + /// return the elt x for this token (token, idx, dstbuf, size) + pub complete_get_elt: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut cmdline_parse_token_hdr_t, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + arg4: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int, + >, + /// get help for this token (token, dstbuf, size) + pub get_help: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut cmdline_parse_token_hdr_t, + arg2: *mut ::std::os::raw::c_char, + arg3: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int, + >, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of cmdline_token_ops"][::std::mem::size_of::() - 32usize]; + [ + "Alignment of cmdline_token_ops", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: cmdline_token_ops::parse", + ][::std::mem::offset_of!(cmdline_token_ops, parse) - 0usize]; + [ + "Offset of field: cmdline_token_ops::complete_get_nb", + ][::std::mem::offset_of!(cmdline_token_ops, complete_get_nb) - 8usize]; + [ + "Offset of field: cmdline_token_ops::complete_get_elt", + ][::std::mem::offset_of!(cmdline_token_ops, complete_get_elt) - 16usize]; + [ + "Offset of field: cmdline_token_ops::get_help", + ][::std::mem::offset_of!(cmdline_token_ops, get_help) - 24usize]; +}; +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum cmdline_numtype { + UINT8 = 0, + UINT16 = 1, + UINT32 = 2, + UINT64 = 3, + INT8 = 4, + INT16 = 5, + INT32 = 6, + INT64 = 7, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct cmdline_token_num_data { + pub type_: cmdline_numtype, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of cmdline_token_num_data", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of cmdline_token_num_data", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: cmdline_token_num_data::type_", + ][::std::mem::offset_of!(cmdline_token_num_data, type_) - 0usize]; +}; +impl Default for cmdline_token_num_data { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct cmdline_token_num { + pub hdr: cmdline_token_hdr, + pub num_data: cmdline_token_num_data, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of cmdline_token_num"][::std::mem::size_of::() - 24usize]; + [ + "Alignment of cmdline_token_num", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: cmdline_token_num::hdr", + ][::std::mem::offset_of!(cmdline_token_num, hdr) - 0usize]; + [ + "Offset of field: cmdline_token_num::num_data", + ][::std::mem::offset_of!(cmdline_token_num, num_data) - 16usize]; +}; +impl Default for cmdline_token_num { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type cmdline_parse_token_num_t = cmdline_token_num; diff --git a/bindgen-tests/tests/expectations/tests/layout_eth_conf.rs b/bindgen-tests/tests/expectations/tests/layout_eth_conf.rs new file mode 100644 index 0000000000..7d975cd979 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/layout_eth_conf.rs @@ -0,0 +1,1723 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +pub const ETH_MQ_RX_RSS_FLAG: u32 = 1; +pub const ETH_MQ_RX_DCB_FLAG: u32 = 2; +pub const ETH_MQ_RX_VMDQ_FLAG: u32 = 4; +pub const ETH_VMDQ_MAX_VLAN_FILTERS: u32 = 64; +pub const ETH_DCB_NUM_USER_PRIORITIES: u32 = 8; +pub const ETH_VMDQ_DCB_NUM_QUEUES: u32 = 128; +pub const ETH_DCB_NUM_QUEUES: u32 = 128; +pub const RTE_ETH_FDIR_MAX_FLEXLEN: u32 = 16; +pub const RTE_ETH_INSET_SIZE_MAX: u32 = 128; +pub const RTE_ETH_FLOW_UNKNOWN: u32 = 0; +pub const RTE_ETH_FLOW_RAW: u32 = 1; +pub const RTE_ETH_FLOW_IPV4: u32 = 2; +pub const RTE_ETH_FLOW_FRAG_IPV4: u32 = 3; +pub const RTE_ETH_FLOW_NONFRAG_IPV4_TCP: u32 = 4; +pub const RTE_ETH_FLOW_NONFRAG_IPV4_UDP: u32 = 5; +pub const RTE_ETH_FLOW_NONFRAG_IPV4_SCTP: u32 = 6; +pub const RTE_ETH_FLOW_NONFRAG_IPV4_OTHER: u32 = 7; +pub const RTE_ETH_FLOW_IPV6: u32 = 8; +pub const RTE_ETH_FLOW_FRAG_IPV6: u32 = 9; +pub const RTE_ETH_FLOW_NONFRAG_IPV6_TCP: u32 = 10; +pub const RTE_ETH_FLOW_NONFRAG_IPV6_UDP: u32 = 11; +pub const RTE_ETH_FLOW_NONFRAG_IPV6_SCTP: u32 = 12; +pub const RTE_ETH_FLOW_NONFRAG_IPV6_OTHER: u32 = 13; +pub const RTE_ETH_FLOW_L2_PAYLOAD: u32 = 14; +pub const RTE_ETH_FLOW_IPV6_EX: u32 = 15; +pub const RTE_ETH_FLOW_IPV6_TCP_EX: u32 = 16; +pub const RTE_ETH_FLOW_IPV6_UDP_EX: u32 = 17; +pub const RTE_ETH_FLOW_PORT: u32 = 18; +pub const RTE_ETH_FLOW_VXLAN: u32 = 19; +pub const RTE_ETH_FLOW_GENEVE: u32 = 20; +pub const RTE_ETH_FLOW_NVGRE: u32 = 21; +pub const RTE_ETH_FLOW_MAX: u32 = 22; +#[repr(u32)] +/** A set of values to identify what method is to be used to route + packets to multiple queues.*/ +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum rte_eth_rx_mq_mode { + /// None of DCB,RSS or VMDQ mode + ETH_MQ_RX_NONE = 0, + /// For RX side, only RSS is on + ETH_MQ_RX_RSS = 1, + /// For RX side,only DCB is on. + ETH_MQ_RX_DCB = 2, + /// Both DCB and RSS enable + ETH_MQ_RX_DCB_RSS = 3, + /// Only VMDQ, no RSS nor DCB + ETH_MQ_RX_VMDQ_ONLY = 4, + /// RSS mode with VMDQ + ETH_MQ_RX_VMDQ_RSS = 5, + /// Use VMDQ+DCB to route traffic to queues + ETH_MQ_RX_VMDQ_DCB = 6, + /// Enable both VMDQ and DCB in VMDq + ETH_MQ_RX_VMDQ_DCB_RSS = 7, +} +/// A structure used to configure the RX features of an Ethernet port. +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_eth_rxmode { + /// The multi-queue packet distribution mode to be used, e.g. RSS. + pub mq_mode: rte_eth_rx_mq_mode, + ///< Only used if jumbo_frame enabled. + pub max_rx_pkt_len: u32, + ///< hdr buf size (header_split enabled). + pub split_hdr_size: u16, + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_eth_rxmode"][::std::mem::size_of::() - 12usize]; + ["Alignment of rte_eth_rxmode"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_eth_rxmode::mq_mode", + ][::std::mem::offset_of!(rte_eth_rxmode, mq_mode) - 0usize]; + [ + "Offset of field: rte_eth_rxmode::max_rx_pkt_len", + ][::std::mem::offset_of!(rte_eth_rxmode, max_rx_pkt_len) - 4usize]; + [ + "Offset of field: rte_eth_rxmode::split_hdr_size", + ][::std::mem::offset_of!(rte_eth_rxmode, split_hdr_size) - 8usize]; +}; +impl Default for rte_eth_rxmode { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl rte_eth_rxmode { + #[inline] + pub fn header_split(&self) -> u16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) } + } + #[inline] + pub fn set_header_split(&mut self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn header_split_raw(this: *const Self) -> u16 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_header_split_raw(this: *mut Self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hw_ip_checksum(&self) -> u16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16) } + } + #[inline] + pub fn set_hw_ip_checksum(&mut self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hw_ip_checksum_raw(this: *const Self) -> u16 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_hw_ip_checksum_raw(this: *mut Self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hw_vlan_filter(&self) -> u16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16) } + } + #[inline] + pub fn set_hw_vlan_filter(&mut self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hw_vlan_filter_raw(this: *const Self) -> u16 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_hw_vlan_filter_raw(this: *mut Self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hw_vlan_strip(&self) -> u16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u16) } + } + #[inline] + pub fn set_hw_vlan_strip(&mut self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hw_vlan_strip_raw(this: *const Self) -> u16 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 3usize, 1u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_hw_vlan_strip_raw(this: *mut Self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hw_vlan_extend(&self) -> u16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u16) } + } + #[inline] + pub fn set_hw_vlan_extend(&mut self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hw_vlan_extend_raw(this: *const Self) -> u16 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 1u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_hw_vlan_extend_raw(this: *mut Self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn jumbo_frame(&self) -> u16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u16) } + } + #[inline] + pub fn set_jumbo_frame(&mut self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn jumbo_frame_raw(this: *const Self) -> u16 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 5usize, 1u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_jumbo_frame_raw(this: *mut Self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hw_strip_crc(&self) -> u16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u16) } + } + #[inline] + pub fn set_hw_strip_crc(&mut self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hw_strip_crc_raw(this: *const Self) -> u16 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 6usize, 1u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_hw_strip_crc_raw(this: *mut Self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn enable_scatter(&self) -> u16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u16) } + } + #[inline] + pub fn set_enable_scatter(&mut self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn enable_scatter_raw(this: *const Self) -> u16 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 7usize, 1u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_enable_scatter_raw(this: *mut Self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn enable_lro(&self) -> u16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u16) } + } + #[inline] + pub fn set_enable_lro(&mut self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn enable_lro_raw(this: *const Self) -> u16 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 8usize, 1u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_enable_lro_raw(this: *mut Self, val: u16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + header_split: u16, + hw_ip_checksum: u16, + hw_vlan_filter: u16, + hw_vlan_strip: u16, + hw_vlan_extend: u16, + jumbo_frame: u16, + hw_strip_crc: u16, + enable_scatter: u16, + enable_lro: u16, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let header_split: u16 = unsafe { + ::std::mem::transmute(header_split) + }; + header_split as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 1u8, + { + let hw_ip_checksum: u16 = unsafe { + ::std::mem::transmute(hw_ip_checksum) + }; + hw_ip_checksum as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 2usize, + 1u8, + { + let hw_vlan_filter: u16 = unsafe { + ::std::mem::transmute(hw_vlan_filter) + }; + hw_vlan_filter as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 3usize, + 1u8, + { + let hw_vlan_strip: u16 = unsafe { + ::std::mem::transmute(hw_vlan_strip) + }; + hw_vlan_strip as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 4usize, + 1u8, + { + let hw_vlan_extend: u16 = unsafe { + ::std::mem::transmute(hw_vlan_extend) + }; + hw_vlan_extend as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 5usize, + 1u8, + { + let jumbo_frame: u16 = unsafe { ::std::mem::transmute(jumbo_frame) }; + jumbo_frame as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 6usize, + 1u8, + { + let hw_strip_crc: u16 = unsafe { + ::std::mem::transmute(hw_strip_crc) + }; + hw_strip_crc as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 7usize, + 1u8, + { + let enable_scatter: u16 = unsafe { + ::std::mem::transmute(enable_scatter) + }; + enable_scatter as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 8usize, + 1u8, + { + let enable_lro: u16 = unsafe { ::std::mem::transmute(enable_lro) }; + enable_lro as u64 + }, + ); + __bindgen_bitfield_unit + } +} +#[repr(u32)] +/** A set of values to identify what method is to be used to transmit + packets using multi-TCs.*/ +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum rte_eth_tx_mq_mode { + ///< It is in neither DCB nor VT mode. + ETH_MQ_TX_NONE = 0, + ///< For TX side,only DCB is on. + ETH_MQ_TX_DCB = 1, + ///< For TX side,both DCB and VT is on. + ETH_MQ_TX_VMDQ_DCB = 2, + ///< Only VT on, no DCB + ETH_MQ_TX_VMDQ_ONLY = 3, +} +/// A structure used to configure the TX features of an Ethernet port. +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_eth_txmode { + ///< TX multi-queues mode. + pub mq_mode: rte_eth_tx_mq_mode, + pub pvid: u16, + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_eth_txmode"][::std::mem::size_of::() - 8usize]; + ["Alignment of rte_eth_txmode"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_eth_txmode::mq_mode", + ][::std::mem::offset_of!(rte_eth_txmode, mq_mode) - 0usize]; + [ + "Offset of field: rte_eth_txmode::pvid", + ][::std::mem::offset_of!(rte_eth_txmode, pvid) - 4usize]; +}; +impl Default for rte_eth_txmode { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl rte_eth_txmode { + #[inline] + pub fn hw_vlan_reject_tagged(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_hw_vlan_reject_tagged(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hw_vlan_reject_tagged_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_hw_vlan_reject_tagged_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hw_vlan_reject_untagged(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } + } + #[inline] + pub fn set_hw_vlan_reject_untagged(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hw_vlan_reject_untagged_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_hw_vlan_reject_untagged_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hw_vlan_insert_pvid(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) } + } + #[inline] + pub fn set_hw_vlan_insert_pvid(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hw_vlan_insert_pvid_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_hw_vlan_insert_pvid_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + hw_vlan_reject_tagged: u8, + hw_vlan_reject_untagged: u8, + hw_vlan_insert_pvid: u8, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let hw_vlan_reject_tagged: u8 = unsafe { + ::std::mem::transmute(hw_vlan_reject_tagged) + }; + hw_vlan_reject_tagged as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 1u8, + { + let hw_vlan_reject_untagged: u8 = unsafe { + ::std::mem::transmute(hw_vlan_reject_untagged) + }; + hw_vlan_reject_untagged as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 2usize, + 1u8, + { + let hw_vlan_insert_pvid: u8 = unsafe { + ::std::mem::transmute(hw_vlan_insert_pvid) + }; + hw_vlan_insert_pvid as u64 + }, + ); + __bindgen_bitfield_unit + } +} +/** A structure used to configure the Receive Side Scaling (RSS) feature + of an Ethernet port. + If not NULL, the *rss_key* pointer of the *rss_conf* structure points + to an array holding the RSS key to use for hashing specific header + fields of received packets. The length of this array should be indicated + by *rss_key_len* below. Otherwise, a default random hash key is used by + the device driver. + + The *rss_key_len* field of the *rss_conf* structure indicates the length + in bytes of the array pointed by *rss_key*. To be compatible, this length + will be checked in i40e only. Others assume 40 bytes to be used as before. + + The *rss_hf* field of the *rss_conf* structure indicates the different + types of IPv4/IPv6 packets to which the RSS hashing must be applied. + Supplying an *rss_hf* equal to zero disables the RSS feature.*/ +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_eth_rss_conf { + ///< If not NULL, 40-byte hash key. + pub rss_key: *mut u8, + ///< hash key length in bytes. + pub rss_key_len: u8, + ///< Hash functions to apply - see below. + pub rss_hf: u64, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_eth_rss_conf"][::std::mem::size_of::() - 24usize]; + [ + "Alignment of rte_eth_rss_conf", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: rte_eth_rss_conf::rss_key", + ][::std::mem::offset_of!(rte_eth_rss_conf, rss_key) - 0usize]; + [ + "Offset of field: rte_eth_rss_conf::rss_key_len", + ][::std::mem::offset_of!(rte_eth_rss_conf, rss_key_len) - 8usize]; + [ + "Offset of field: rte_eth_rss_conf::rss_hf", + ][::std::mem::offset_of!(rte_eth_rss_conf, rss_hf) - 16usize]; +}; +impl Default for rte_eth_rss_conf { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(u32)] +/** This enum indicates the possible number of traffic classes + in DCB configratioins*/ +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum rte_eth_nb_tcs { + ///< 4 TCs with DCB. + ETH_4_TCS = 4, + ///< 8 TCs with DCB. + ETH_8_TCS = 8, +} +#[repr(u32)] +/** This enum indicates the possible number of queue pools + in VMDQ configurations.*/ +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum rte_eth_nb_pools { + ///< 8 VMDq pools. + ETH_8_POOLS = 8, + ///< 16 VMDq pools. + ETH_16_POOLS = 16, + ///< 32 VMDq pools. + ETH_32_POOLS = 32, + ///< 64 VMDq pools. + ETH_64_POOLS = 64, +} +/** A structure used to configure the VMDQ+DCB feature + of an Ethernet port. + + Using this feature, packets are routed to a pool of queues, based + on the vlan ID in the vlan tag, and then to a specific queue within + that pool, using the user priority vlan tag field. + + A default pool may be used, if desired, to route all traffic which + does not match the vlan filter rules.*/ +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_eth_vmdq_dcb_conf { + ///< With DCB, 16 or 32 pools + pub nb_queue_pools: rte_eth_nb_pools, + ///< If non-zero, use a default pool + pub enable_default_pool: u8, + ///< The default pool, if applicable + pub default_pool: u8, + ///< We can have up to 64 filters/mappings + pub nb_pool_maps: u8, + ///< VMDq vlan pool maps. + pub pool_map: [rte_eth_vmdq_dcb_conf__bindgen_ty_1; 64usize], + pub dcb_tc: [u8; 8usize], +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_eth_vmdq_dcb_conf__bindgen_ty_1 { + ///< The vlan ID of the received frame + pub vlan_id: u16, + ///< Bitmask of pools for packet rx + pub pools: u64, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_eth_vmdq_dcb_conf__bindgen_ty_1", + ][::std::mem::size_of::() - 16usize]; + [ + "Alignment of rte_eth_vmdq_dcb_conf__bindgen_ty_1", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: rte_eth_vmdq_dcb_conf__bindgen_ty_1::vlan_id", + ][::std::mem::offset_of!(rte_eth_vmdq_dcb_conf__bindgen_ty_1, vlan_id) - 0usize]; + [ + "Offset of field: rte_eth_vmdq_dcb_conf__bindgen_ty_1::pools", + ][::std::mem::offset_of!(rte_eth_vmdq_dcb_conf__bindgen_ty_1, pools) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_eth_vmdq_dcb_conf", + ][::std::mem::size_of::() - 1040usize]; + [ + "Alignment of rte_eth_vmdq_dcb_conf", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: rte_eth_vmdq_dcb_conf::nb_queue_pools", + ][::std::mem::offset_of!(rte_eth_vmdq_dcb_conf, nb_queue_pools) - 0usize]; + [ + "Offset of field: rte_eth_vmdq_dcb_conf::enable_default_pool", + ][::std::mem::offset_of!(rte_eth_vmdq_dcb_conf, enable_default_pool) - 4usize]; + [ + "Offset of field: rte_eth_vmdq_dcb_conf::default_pool", + ][::std::mem::offset_of!(rte_eth_vmdq_dcb_conf, default_pool) - 5usize]; + [ + "Offset of field: rte_eth_vmdq_dcb_conf::nb_pool_maps", + ][::std::mem::offset_of!(rte_eth_vmdq_dcb_conf, nb_pool_maps) - 6usize]; + [ + "Offset of field: rte_eth_vmdq_dcb_conf::pool_map", + ][::std::mem::offset_of!(rte_eth_vmdq_dcb_conf, pool_map) - 8usize]; + [ + "Offset of field: rte_eth_vmdq_dcb_conf::dcb_tc", + ][::std::mem::offset_of!(rte_eth_vmdq_dcb_conf, dcb_tc) - 1032usize]; +}; +impl Default for rte_eth_vmdq_dcb_conf { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_eth_dcb_rx_conf { + ///< Possible DCB TCs, 4 or 8 TCs + pub nb_tcs: rte_eth_nb_tcs, + /// Traffic class each UP mapped to. + pub dcb_tc: [u8; 8usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_eth_dcb_rx_conf", + ][::std::mem::size_of::() - 12usize]; + [ + "Alignment of rte_eth_dcb_rx_conf", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_eth_dcb_rx_conf::nb_tcs", + ][::std::mem::offset_of!(rte_eth_dcb_rx_conf, nb_tcs) - 0usize]; + [ + "Offset of field: rte_eth_dcb_rx_conf::dcb_tc", + ][::std::mem::offset_of!(rte_eth_dcb_rx_conf, dcb_tc) - 4usize]; +}; +impl Default for rte_eth_dcb_rx_conf { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_eth_vmdq_dcb_tx_conf { + ///< With DCB, 16 or 32 pools. + pub nb_queue_pools: rte_eth_nb_pools, + /// Traffic class each UP mapped to. + pub dcb_tc: [u8; 8usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_eth_vmdq_dcb_tx_conf", + ][::std::mem::size_of::() - 12usize]; + [ + "Alignment of rte_eth_vmdq_dcb_tx_conf", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_eth_vmdq_dcb_tx_conf::nb_queue_pools", + ][::std::mem::offset_of!(rte_eth_vmdq_dcb_tx_conf, nb_queue_pools) - 0usize]; + [ + "Offset of field: rte_eth_vmdq_dcb_tx_conf::dcb_tc", + ][::std::mem::offset_of!(rte_eth_vmdq_dcb_tx_conf, dcb_tc) - 4usize]; +}; +impl Default for rte_eth_vmdq_dcb_tx_conf { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_eth_dcb_tx_conf { + ///< Possible DCB TCs, 4 or 8 TCs. + pub nb_tcs: rte_eth_nb_tcs, + /// Traffic class each UP mapped to. + pub dcb_tc: [u8; 8usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_eth_dcb_tx_conf", + ][::std::mem::size_of::() - 12usize]; + [ + "Alignment of rte_eth_dcb_tx_conf", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_eth_dcb_tx_conf::nb_tcs", + ][::std::mem::offset_of!(rte_eth_dcb_tx_conf, nb_tcs) - 0usize]; + [ + "Offset of field: rte_eth_dcb_tx_conf::dcb_tc", + ][::std::mem::offset_of!(rte_eth_dcb_tx_conf, dcb_tc) - 4usize]; +}; +impl Default for rte_eth_dcb_tx_conf { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_eth_vmdq_tx_conf { + ///< VMDq mode, 64 pools. + pub nb_queue_pools: rte_eth_nb_pools, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_eth_vmdq_tx_conf", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of rte_eth_vmdq_tx_conf", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_eth_vmdq_tx_conf::nb_queue_pools", + ][::std::mem::offset_of!(rte_eth_vmdq_tx_conf, nb_queue_pools) - 0usize]; +}; +impl Default for rte_eth_vmdq_tx_conf { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_eth_vmdq_rx_conf { + ///< VMDq only mode, 8 or 64 pools + pub nb_queue_pools: rte_eth_nb_pools, + ///< If non-zero, use a default pool + pub enable_default_pool: u8, + ///< The default pool, if applicable + pub default_pool: u8, + ///< Enable VT loop back + pub enable_loop_back: u8, + ///< We can have up to 64 filters/mappings + pub nb_pool_maps: u8, + ///< Flags from ETH_VMDQ_ACCEPT_* + pub rx_mode: u32, + ///< VMDq vlan pool maps. + pub pool_map: [rte_eth_vmdq_rx_conf__bindgen_ty_1; 64usize], +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_eth_vmdq_rx_conf__bindgen_ty_1 { + ///< The vlan ID of the received frame + pub vlan_id: u16, + ///< Bitmask of pools for packet rx + pub pools: u64, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_eth_vmdq_rx_conf__bindgen_ty_1", + ][::std::mem::size_of::() - 16usize]; + [ + "Alignment of rte_eth_vmdq_rx_conf__bindgen_ty_1", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: rte_eth_vmdq_rx_conf__bindgen_ty_1::vlan_id", + ][::std::mem::offset_of!(rte_eth_vmdq_rx_conf__bindgen_ty_1, vlan_id) - 0usize]; + [ + "Offset of field: rte_eth_vmdq_rx_conf__bindgen_ty_1::pools", + ][::std::mem::offset_of!(rte_eth_vmdq_rx_conf__bindgen_ty_1, pools) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_eth_vmdq_rx_conf", + ][::std::mem::size_of::() - 1040usize]; + [ + "Alignment of rte_eth_vmdq_rx_conf", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: rte_eth_vmdq_rx_conf::nb_queue_pools", + ][::std::mem::offset_of!(rte_eth_vmdq_rx_conf, nb_queue_pools) - 0usize]; + [ + "Offset of field: rte_eth_vmdq_rx_conf::enable_default_pool", + ][::std::mem::offset_of!(rte_eth_vmdq_rx_conf, enable_default_pool) - 4usize]; + [ + "Offset of field: rte_eth_vmdq_rx_conf::default_pool", + ][::std::mem::offset_of!(rte_eth_vmdq_rx_conf, default_pool) - 5usize]; + [ + "Offset of field: rte_eth_vmdq_rx_conf::enable_loop_back", + ][::std::mem::offset_of!(rte_eth_vmdq_rx_conf, enable_loop_back) - 6usize]; + [ + "Offset of field: rte_eth_vmdq_rx_conf::nb_pool_maps", + ][::std::mem::offset_of!(rte_eth_vmdq_rx_conf, nb_pool_maps) - 7usize]; + [ + "Offset of field: rte_eth_vmdq_rx_conf::rx_mode", + ][::std::mem::offset_of!(rte_eth_vmdq_rx_conf, rx_mode) - 8usize]; + [ + "Offset of field: rte_eth_vmdq_rx_conf::pool_map", + ][::std::mem::offset_of!(rte_eth_vmdq_rx_conf, pool_map) - 16usize]; +}; +impl Default for rte_eth_vmdq_rx_conf { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(u32)] +/// Flow Director setting modes: none, signature or perfect. +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum rte_fdir_mode { + ///< Disable FDIR support. + RTE_FDIR_MODE_NONE = 0, + ///< Enable FDIR signature filter mode. + RTE_FDIR_MODE_SIGNATURE = 1, + ///< Enable FDIR perfect filter mode. + RTE_FDIR_MODE_PERFECT = 2, + ///< Enable FDIR filter mode - MAC VLAN. + RTE_FDIR_MODE_PERFECT_MAC_VLAN = 3, + ///< Enable FDIR filter mode - tunnel. + RTE_FDIR_MODE_PERFECT_TUNNEL = 4, +} +#[repr(u32)] +/** Memory space that can be configured to store Flow Director filters + in the board memory.*/ +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum rte_fdir_pballoc_type { + ///< 64k. + RTE_FDIR_PBALLOC_64K = 0, + ///< 128k. + RTE_FDIR_PBALLOC_128K = 1, + ///< 256k. + RTE_FDIR_PBALLOC_256K = 2, +} +#[repr(u32)] +/// Select report mode of FDIR hash information in RX descriptors. +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum rte_fdir_status_mode { + ///< Never report FDIR hash. + RTE_FDIR_NO_REPORT_STATUS = 0, + ///< Only report FDIR hash for matching pkts. + RTE_FDIR_REPORT_STATUS = 1, + ///< Always report FDIR hash. + RTE_FDIR_REPORT_STATUS_ALWAYS = 2, +} +/// A structure used to define the input for IPV4 flow +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_eth_ipv4_flow { + ///< IPv4 source address in big endian. + pub src_ip: u32, + ///< IPv4 destination address in big endian. + pub dst_ip: u32, + ///< Type of service to match. + pub tos: u8, + ///< Time to live to match. + pub ttl: u8, + ///< Protocol, next header in big endian. + pub proto: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_eth_ipv4_flow"][::std::mem::size_of::() - 12usize]; + [ + "Alignment of rte_eth_ipv4_flow", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_eth_ipv4_flow::src_ip", + ][::std::mem::offset_of!(rte_eth_ipv4_flow, src_ip) - 0usize]; + [ + "Offset of field: rte_eth_ipv4_flow::dst_ip", + ][::std::mem::offset_of!(rte_eth_ipv4_flow, dst_ip) - 4usize]; + [ + "Offset of field: rte_eth_ipv4_flow::tos", + ][::std::mem::offset_of!(rte_eth_ipv4_flow, tos) - 8usize]; + [ + "Offset of field: rte_eth_ipv4_flow::ttl", + ][::std::mem::offset_of!(rte_eth_ipv4_flow, ttl) - 9usize]; + [ + "Offset of field: rte_eth_ipv4_flow::proto", + ][::std::mem::offset_of!(rte_eth_ipv4_flow, proto) - 10usize]; +}; +/// A structure used to define the input for IPV6 flow +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_eth_ipv6_flow { + ///< IPv6 source address in big endian. + pub src_ip: [u32; 4usize], + ///< IPv6 destination address in big endian. + pub dst_ip: [u32; 4usize], + ///< Traffic class to match. + pub tc: u8, + ///< Protocol, next header to match. + pub proto: u8, + ///< Hop limits to match. + pub hop_limits: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_eth_ipv6_flow"][::std::mem::size_of::() - 36usize]; + [ + "Alignment of rte_eth_ipv6_flow", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_eth_ipv6_flow::src_ip", + ][::std::mem::offset_of!(rte_eth_ipv6_flow, src_ip) - 0usize]; + [ + "Offset of field: rte_eth_ipv6_flow::dst_ip", + ][::std::mem::offset_of!(rte_eth_ipv6_flow, dst_ip) - 16usize]; + [ + "Offset of field: rte_eth_ipv6_flow::tc", + ][::std::mem::offset_of!(rte_eth_ipv6_flow, tc) - 32usize]; + [ + "Offset of field: rte_eth_ipv6_flow::proto", + ][::std::mem::offset_of!(rte_eth_ipv6_flow, proto) - 33usize]; + [ + "Offset of field: rte_eth_ipv6_flow::hop_limits", + ][::std::mem::offset_of!(rte_eth_ipv6_flow, hop_limits) - 34usize]; +}; +/** A structure used to configure FDIR masks that are used by the device + to match the various fields of RX packet headers.*/ +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_eth_fdir_masks { + ///< Bit mask for vlan_tci in big endian + pub vlan_tci_mask: u16, + /// Bit mask for ipv4 flow in big endian. + pub ipv4_mask: rte_eth_ipv4_flow, + /// Bit maks for ipv6 flow in big endian. + pub ipv6_mask: rte_eth_ipv6_flow, + /// Bit mask for L4 source port in big endian. + pub src_port_mask: u16, + /// Bit mask for L4 destination port in big endian. + pub dst_port_mask: u16, + /** 6 bit mask for proper 6 bytes of Mac address, bit 0 matches the +first byte on the wire*/ + pub mac_addr_byte_mask: u8, + /// Bit mask for tunnel ID in big endian. + pub tunnel_id_mask: u32, + /**< 1 - Match tunnel type, +0 - Ignore tunnel type.*/ + pub tunnel_type_mask: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_eth_fdir_masks", + ][::std::mem::size_of::() - 68usize]; + [ + "Alignment of rte_eth_fdir_masks", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_eth_fdir_masks::vlan_tci_mask", + ][::std::mem::offset_of!(rte_eth_fdir_masks, vlan_tci_mask) - 0usize]; + [ + "Offset of field: rte_eth_fdir_masks::ipv4_mask", + ][::std::mem::offset_of!(rte_eth_fdir_masks, ipv4_mask) - 4usize]; + [ + "Offset of field: rte_eth_fdir_masks::ipv6_mask", + ][::std::mem::offset_of!(rte_eth_fdir_masks, ipv6_mask) - 16usize]; + [ + "Offset of field: rte_eth_fdir_masks::src_port_mask", + ][::std::mem::offset_of!(rte_eth_fdir_masks, src_port_mask) - 52usize]; + [ + "Offset of field: rte_eth_fdir_masks::dst_port_mask", + ][::std::mem::offset_of!(rte_eth_fdir_masks, dst_port_mask) - 54usize]; + [ + "Offset of field: rte_eth_fdir_masks::mac_addr_byte_mask", + ][::std::mem::offset_of!(rte_eth_fdir_masks, mac_addr_byte_mask) - 56usize]; + [ + "Offset of field: rte_eth_fdir_masks::tunnel_id_mask", + ][::std::mem::offset_of!(rte_eth_fdir_masks, tunnel_id_mask) - 60usize]; + [ + "Offset of field: rte_eth_fdir_masks::tunnel_type_mask", + ][::std::mem::offset_of!(rte_eth_fdir_masks, tunnel_type_mask) - 64usize]; +}; +#[repr(u32)] +/// Payload type +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum rte_eth_payload_type { + RTE_ETH_PAYLOAD_UNKNOWN = 0, + RTE_ETH_RAW_PAYLOAD = 1, + RTE_ETH_L2_PAYLOAD = 2, + RTE_ETH_L3_PAYLOAD = 3, + RTE_ETH_L4_PAYLOAD = 4, + RTE_ETH_PAYLOAD_MAX = 8, +} +/** A structure used to select bytes extracted from the protocol layers to + flexible payload for filter*/ +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_eth_flex_payload_cfg { + ///< Payload type + pub type_: rte_eth_payload_type, + pub src_offset: [u16; 16usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_eth_flex_payload_cfg", + ][::std::mem::size_of::() - 36usize]; + [ + "Alignment of rte_eth_flex_payload_cfg", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_eth_flex_payload_cfg::type_", + ][::std::mem::offset_of!(rte_eth_flex_payload_cfg, type_) - 0usize]; + [ + "Offset of field: rte_eth_flex_payload_cfg::src_offset", + ][::std::mem::offset_of!(rte_eth_flex_payload_cfg, src_offset) - 4usize]; +}; +impl Default for rte_eth_flex_payload_cfg { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +/** A structure used to define FDIR masks for flexible payload + for each flow type*/ +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_eth_fdir_flex_mask { + pub flow_type: u16, + pub mask: [u8; 16usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_eth_fdir_flex_mask", + ][::std::mem::size_of::() - 18usize]; + [ + "Alignment of rte_eth_fdir_flex_mask", + ][::std::mem::align_of::() - 2usize]; + [ + "Offset of field: rte_eth_fdir_flex_mask::flow_type", + ][::std::mem::offset_of!(rte_eth_fdir_flex_mask, flow_type) - 0usize]; + [ + "Offset of field: rte_eth_fdir_flex_mask::mask", + ][::std::mem::offset_of!(rte_eth_fdir_flex_mask, mask) - 2usize]; +}; +/** A structure used to define all flexible payload related setting + include flex payload and flex mask*/ +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_eth_fdir_flex_conf { + ///< The number of following payload cfg + pub nb_payloads: u16, + ///< The number of following mask + pub nb_flexmasks: u16, + pub flex_set: [rte_eth_flex_payload_cfg; 8usize], + pub flex_mask: [rte_eth_fdir_flex_mask; 22usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_eth_fdir_flex_conf", + ][::std::mem::size_of::() - 688usize]; + [ + "Alignment of rte_eth_fdir_flex_conf", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_eth_fdir_flex_conf::nb_payloads", + ][::std::mem::offset_of!(rte_eth_fdir_flex_conf, nb_payloads) - 0usize]; + [ + "Offset of field: rte_eth_fdir_flex_conf::nb_flexmasks", + ][::std::mem::offset_of!(rte_eth_fdir_flex_conf, nb_flexmasks) - 2usize]; + [ + "Offset of field: rte_eth_fdir_flex_conf::flex_set", + ][::std::mem::offset_of!(rte_eth_fdir_flex_conf, flex_set) - 4usize]; + [ + "Offset of field: rte_eth_fdir_flex_conf::flex_mask", + ][::std::mem::offset_of!(rte_eth_fdir_flex_conf, flex_mask) - 292usize]; +}; +impl Default for rte_eth_fdir_flex_conf { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +/** A structure used to configure the Flow Director (FDIR) feature + of an Ethernet port. + + If mode is RTE_FDIR_DISABLE, the pballoc value is ignored.*/ +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_fdir_conf { + ///< Flow Director mode. + pub mode: rte_fdir_mode, + ///< Space for FDIR filters. + pub pballoc: rte_fdir_pballoc_type, + ///< How to report FDIR hash. + pub status: rte_fdir_status_mode, + /// RX queue of packets matching a "drop" filter in perfect mode. + pub drop_queue: u8, + pub mask: rte_eth_fdir_masks, + pub flex_conf: rte_eth_fdir_flex_conf, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_fdir_conf"][::std::mem::size_of::() - 772usize]; + ["Alignment of rte_fdir_conf"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_fdir_conf::mode", + ][::std::mem::offset_of!(rte_fdir_conf, mode) - 0usize]; + [ + "Offset of field: rte_fdir_conf::pballoc", + ][::std::mem::offset_of!(rte_fdir_conf, pballoc) - 4usize]; + [ + "Offset of field: rte_fdir_conf::status", + ][::std::mem::offset_of!(rte_fdir_conf, status) - 8usize]; + [ + "Offset of field: rte_fdir_conf::drop_queue", + ][::std::mem::offset_of!(rte_fdir_conf, drop_queue) - 12usize]; + [ + "Offset of field: rte_fdir_conf::mask", + ][::std::mem::offset_of!(rte_fdir_conf, mask) - 16usize]; + [ + "Offset of field: rte_fdir_conf::flex_conf", + ][::std::mem::offset_of!(rte_fdir_conf, flex_conf) - 84usize]; +}; +impl Default for rte_fdir_conf { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +/// A structure used to enable/disable specific device interrupts. +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_intr_conf { + /// enable/disable lsc interrupt. 0 (default) - disable, 1 enable + pub lsc: u16, + /// enable/disable rxq interrupt. 0 (default) - disable, 1 enable + pub rxq: u16, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_intr_conf"][::std::mem::size_of::() - 4usize]; + ["Alignment of rte_intr_conf"][::std::mem::align_of::() - 2usize]; + [ + "Offset of field: rte_intr_conf::lsc", + ][::std::mem::offset_of!(rte_intr_conf, lsc) - 0usize]; + [ + "Offset of field: rte_intr_conf::rxq", + ][::std::mem::offset_of!(rte_intr_conf, rxq) - 2usize]; +}; +/** A structure used to configure an Ethernet port. + Depending upon the RX multi-queue mode, extra advanced + configuration settings may be needed.*/ +#[repr(C)] +#[derive(Copy, Clone)] +pub struct rte_eth_conf { + /**< bitmap of ETH_LINK_SPEED_XXX of speeds to be +used. ETH_LINK_SPEED_FIXED disables link +autonegotiation, and a unique speed shall be +set. Otherwise, the bitmap defines the set of +speeds to be advertised. If the special value +ETH_LINK_SPEED_AUTONEG (0) is used, all speeds +supported are advertised.*/ + pub link_speeds: u32, + ///< Port RX configuration. + pub rxmode: rte_eth_rxmode, + ///< Port TX configuration. + pub txmode: rte_eth_txmode, + /**< Loopback operation mode. By default the value +is 0, meaning the loopback mode is disabled. +Read the datasheet of given ethernet controller +for details. The possible values of this field +are defined in implementation of each driver.*/ + pub lpbk_mode: u32, + ///< Port RX filtering configuration (union). + pub rx_adv_conf: rte_eth_conf__bindgen_ty_1, + ///< Port TX DCB configuration (union). + pub tx_adv_conf: rte_eth_conf__bindgen_ty_2, + /** Currently,Priority Flow Control(PFC) are supported,if DCB with PFC +is needed,and the variable must be set ETH_DCB_PFC_SUPPORT.*/ + pub dcb_capability_en: u32, + ///< FDIR configuration. + pub fdir_conf: rte_fdir_conf, + ///< Interrupt mode configuration. + pub intr_conf: rte_intr_conf, +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_eth_conf__bindgen_ty_1 { + ///< Port RSS configuration + pub rss_conf: rte_eth_rss_conf, + pub vmdq_dcb_conf: rte_eth_vmdq_dcb_conf, + pub dcb_rx_conf: rte_eth_dcb_rx_conf, + pub vmdq_rx_conf: rte_eth_vmdq_rx_conf, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_eth_conf__bindgen_ty_1", + ][::std::mem::size_of::() - 2120usize]; + [ + "Alignment of rte_eth_conf__bindgen_ty_1", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: rte_eth_conf__bindgen_ty_1::rss_conf", + ][::std::mem::offset_of!(rte_eth_conf__bindgen_ty_1, rss_conf) - 0usize]; + [ + "Offset of field: rte_eth_conf__bindgen_ty_1::vmdq_dcb_conf", + ][::std::mem::offset_of!(rte_eth_conf__bindgen_ty_1, vmdq_dcb_conf) - 24usize]; + [ + "Offset of field: rte_eth_conf__bindgen_ty_1::dcb_rx_conf", + ][::std::mem::offset_of!(rte_eth_conf__bindgen_ty_1, dcb_rx_conf) - 1064usize]; + [ + "Offset of field: rte_eth_conf__bindgen_ty_1::vmdq_rx_conf", + ][::std::mem::offset_of!(rte_eth_conf__bindgen_ty_1, vmdq_rx_conf) - 1080usize]; +}; +impl Default for rte_eth_conf__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union rte_eth_conf__bindgen_ty_2 { + pub vmdq_dcb_tx_conf: rte_eth_vmdq_dcb_tx_conf, + pub dcb_tx_conf: rte_eth_dcb_tx_conf, + pub vmdq_tx_conf: rte_eth_vmdq_tx_conf, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_eth_conf__bindgen_ty_2", + ][::std::mem::size_of::() - 12usize]; + [ + "Alignment of rte_eth_conf__bindgen_ty_2", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_eth_conf__bindgen_ty_2::vmdq_dcb_tx_conf", + ][::std::mem::offset_of!(rte_eth_conf__bindgen_ty_2, vmdq_dcb_tx_conf) - 0usize]; + [ + "Offset of field: rte_eth_conf__bindgen_ty_2::dcb_tx_conf", + ][::std::mem::offset_of!(rte_eth_conf__bindgen_ty_2, dcb_tx_conf) - 0usize]; + [ + "Offset of field: rte_eth_conf__bindgen_ty_2::vmdq_tx_conf", + ][::std::mem::offset_of!(rte_eth_conf__bindgen_ty_2, vmdq_tx_conf) - 0usize]; +}; +impl Default for rte_eth_conf__bindgen_ty_2 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_eth_conf"][::std::mem::size_of::() - 2944usize]; + ["Alignment of rte_eth_conf"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: rte_eth_conf::link_speeds", + ][::std::mem::offset_of!(rte_eth_conf, link_speeds) - 0usize]; + [ + "Offset of field: rte_eth_conf::rxmode", + ][::std::mem::offset_of!(rte_eth_conf, rxmode) - 4usize]; + [ + "Offset of field: rte_eth_conf::txmode", + ][::std::mem::offset_of!(rte_eth_conf, txmode) - 16usize]; + [ + "Offset of field: rte_eth_conf::lpbk_mode", + ][::std::mem::offset_of!(rte_eth_conf, lpbk_mode) - 24usize]; + [ + "Offset of field: rte_eth_conf::rx_adv_conf", + ][::std::mem::offset_of!(rte_eth_conf, rx_adv_conf) - 32usize]; + [ + "Offset of field: rte_eth_conf::tx_adv_conf", + ][::std::mem::offset_of!(rte_eth_conf, tx_adv_conf) - 2152usize]; + [ + "Offset of field: rte_eth_conf::dcb_capability_en", + ][::std::mem::offset_of!(rte_eth_conf, dcb_capability_en) - 2164usize]; + [ + "Offset of field: rte_eth_conf::fdir_conf", + ][::std::mem::offset_of!(rte_eth_conf, fdir_conf) - 2168usize]; + [ + "Offset of field: rte_eth_conf::intr_conf", + ][::std::mem::offset_of!(rte_eth_conf, intr_conf) - 2940usize]; +}; +impl Default for rte_eth_conf { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/layout_kni_mbuf.rs b/bindgen-tests/tests/expectations/tests/layout_kni_mbuf.rs new file mode 100644 index 0000000000..38f49fb4f0 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/layout_kni_mbuf.rs @@ -0,0 +1,84 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const RTE_CACHE_LINE_MIN_SIZE: u32 = 64; +pub const RTE_CACHE_LINE_SIZE: u32 = 64; +#[repr(C)] +#[repr(align(64))] +#[derive(Debug, Copy, Clone)] +pub struct rte_kni_mbuf { + pub buf_addr: *mut ::std::os::raw::c_void, + pub buf_physaddr: u64, + pub pad0: [::std::os::raw::c_char; 2usize], + ///< Start address of data in segment buffer. + pub data_off: u16, + pub pad1: [::std::os::raw::c_char; 2usize], + ///< Number of segments. + pub nb_segs: u8, + pub pad4: [::std::os::raw::c_char; 1usize], + ///< Offload features. + pub ol_flags: u64, + pub pad2: [::std::os::raw::c_char; 4usize], + ///< Total pkt len: sum of all segment data_len. + pub pkt_len: u32, + ///< Amount of data in segment buffer. + pub data_len: u16, + pub __bindgen_padding_0: [u8; 22usize], + pub pad3: [::std::os::raw::c_char; 8usize], + pub pool: *mut ::std::os::raw::c_void, + pub next: *mut ::std::os::raw::c_void, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_kni_mbuf"][::std::mem::size_of::() - 128usize]; + ["Alignment of rte_kni_mbuf"][::std::mem::align_of::() - 64usize]; + [ + "Offset of field: rte_kni_mbuf::buf_addr", + ][::std::mem::offset_of!(rte_kni_mbuf, buf_addr) - 0usize]; + [ + "Offset of field: rte_kni_mbuf::buf_physaddr", + ][::std::mem::offset_of!(rte_kni_mbuf, buf_physaddr) - 8usize]; + [ + "Offset of field: rte_kni_mbuf::pad0", + ][::std::mem::offset_of!(rte_kni_mbuf, pad0) - 16usize]; + [ + "Offset of field: rte_kni_mbuf::data_off", + ][::std::mem::offset_of!(rte_kni_mbuf, data_off) - 18usize]; + [ + "Offset of field: rte_kni_mbuf::pad1", + ][::std::mem::offset_of!(rte_kni_mbuf, pad1) - 20usize]; + [ + "Offset of field: rte_kni_mbuf::nb_segs", + ][::std::mem::offset_of!(rte_kni_mbuf, nb_segs) - 22usize]; + [ + "Offset of field: rte_kni_mbuf::pad4", + ][::std::mem::offset_of!(rte_kni_mbuf, pad4) - 23usize]; + [ + "Offset of field: rte_kni_mbuf::ol_flags", + ][::std::mem::offset_of!(rte_kni_mbuf, ol_flags) - 24usize]; + [ + "Offset of field: rte_kni_mbuf::pad2", + ][::std::mem::offset_of!(rte_kni_mbuf, pad2) - 32usize]; + [ + "Offset of field: rte_kni_mbuf::pkt_len", + ][::std::mem::offset_of!(rte_kni_mbuf, pkt_len) - 36usize]; + [ + "Offset of field: rte_kni_mbuf::data_len", + ][::std::mem::offset_of!(rte_kni_mbuf, data_len) - 40usize]; + [ + "Offset of field: rte_kni_mbuf::pad3", + ][::std::mem::offset_of!(rte_kni_mbuf, pad3) - 64usize]; + [ + "Offset of field: rte_kni_mbuf::pool", + ][::std::mem::offset_of!(rte_kni_mbuf, pool) - 72usize]; + [ + "Offset of field: rte_kni_mbuf::next", + ][::std::mem::offset_of!(rte_kni_mbuf, next) - 80usize]; +}; +impl Default for rte_kni_mbuf { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/layout_large_align_field.rs b/bindgen-tests/tests/expectations/tests/layout_large_align_field.rs new file mode 100644 index 0000000000..0ccd40a5f8 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/layout_large_align_field.rs @@ -0,0 +1,357 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)] +#[repr(C, align(8))] +pub struct __BindgenOpaqueArray8(pub T); +impl Default for __BindgenOpaqueArray8<[T; N]> { + fn default() -> Self { + Self([::default(); N]) + } +} +#[repr(C)] +#[derive(Default)] +pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); +impl __IncompleteArrayField { + #[inline] + pub const fn new() -> Self { + __IncompleteArrayField(::std::marker::PhantomData, []) + } + #[inline] + pub fn as_ptr(&self) -> *const T { + self as *const _ as *const T + } + #[inline] + pub fn as_mut_ptr(&mut self) -> *mut T { + self as *mut _ as *mut T + } + #[inline] + pub unsafe fn as_slice(&self, len: usize) -> &[T] { + ::std::slice::from_raw_parts(self.as_ptr(), len) + } + #[inline] + pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { + ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) + } +} +impl ::std::fmt::Debug for __IncompleteArrayField { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + fmt.write_str("__IncompleteArrayField") + } +} +pub const RTE_CACHE_LINE_SIZE: u32 = 64; +pub const RTE_LIBRTE_IP_FRAG_MAX_FRAG: u32 = 4; +pub const IP_LAST_FRAG_IDX: _bindgen_ty_1 = _bindgen_ty_1::IP_LAST_FRAG_IDX; +pub const IP_FIRST_FRAG_IDX: _bindgen_ty_1 = _bindgen_ty_1::IP_FIRST_FRAG_IDX; +pub const IP_MIN_FRAG_NUM: _bindgen_ty_1 = _bindgen_ty_1::IP_MIN_FRAG_NUM; +pub const IP_MAX_FRAG_NUM: _bindgen_ty_1 = _bindgen_ty_1::IP_MAX_FRAG_NUM; +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _bindgen_ty_1 { + ///< index of last fragment + IP_LAST_FRAG_IDX = 0, + ///< index of first fragment + IP_FIRST_FRAG_IDX = 1, + ///< minimum number of fragments + IP_MIN_FRAG_NUM = 2, + IP_MAX_FRAG_NUM = 4, +} +/// @internal fragmented mbuf +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ip_frag { + ///< offset into the packet + pub ofs: u16, + ///< length of fragment + pub len: u16, + ///< fragment mbuf + pub mb: *mut rte_mbuf, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ip_frag"][::std::mem::size_of::() - 16usize]; + ["Alignment of ip_frag"][::std::mem::align_of::() - 8usize]; + ["Offset of field: ip_frag::ofs"][::std::mem::offset_of!(ip_frag, ofs) - 0usize]; + ["Offset of field: ip_frag::len"][::std::mem::offset_of!(ip_frag, len) - 2usize]; + ["Offset of field: ip_frag::mb"][::std::mem::offset_of!(ip_frag, mb) - 8usize]; +}; +impl Default for ip_frag { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +/// @internal to uniquely indetify fragmented datagram. +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct ip_frag_key { + ///< src address, first 8 bytes used for IPv4 + pub src_dst: [u64; 4usize], + ///< dst address + pub id: u32, + ///< src/dst key length + pub key_len: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ip_frag_key"][::std::mem::size_of::() - 40usize]; + ["Alignment of ip_frag_key"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: ip_frag_key::src_dst", + ][::std::mem::offset_of!(ip_frag_key, src_dst) - 0usize]; + [ + "Offset of field: ip_frag_key::id", + ][::std::mem::offset_of!(ip_frag_key, id) - 32usize]; + [ + "Offset of field: ip_frag_key::key_len", + ][::std::mem::offset_of!(ip_frag_key, key_len) - 36usize]; +}; +/** @internal Fragmented packet to reassemble. + First two entries in the frags[] array are for the last and first fragments.*/ +#[repr(C)] +#[repr(align(64))] +#[derive(Debug, Copy, Clone)] +pub struct ip_frag_pkt { + ///< LRU list + pub lru: ip_frag_pkt__bindgen_ty_1, + ///< fragmentation key + pub key: ip_frag_key, + ///< creation timestamp + pub start: u64, + ///< expected reassembled size + pub total_size: u32, + ///< size of fragments received + pub frag_size: u32, + ///< index of next entry to fill + pub last_idx: u32, + ///< fragments + pub frags: [ip_frag; 4usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ip_frag_pkt__bindgen_ty_1 { + pub tqe_next: *mut ip_frag_pkt, + pub tqe_prev: *mut *mut ip_frag_pkt, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of ip_frag_pkt__bindgen_ty_1", + ][::std::mem::size_of::() - 16usize]; + [ + "Alignment of ip_frag_pkt__bindgen_ty_1", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: ip_frag_pkt__bindgen_ty_1::tqe_next", + ][::std::mem::offset_of!(ip_frag_pkt__bindgen_ty_1, tqe_next) - 0usize]; + [ + "Offset of field: ip_frag_pkt__bindgen_ty_1::tqe_prev", + ][::std::mem::offset_of!(ip_frag_pkt__bindgen_ty_1, tqe_prev) - 8usize]; +}; +impl Default for ip_frag_pkt__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ip_frag_pkt"][::std::mem::size_of::() - 192usize]; + ["Alignment of ip_frag_pkt"][::std::mem::align_of::() - 64usize]; + [ + "Offset of field: ip_frag_pkt::lru", + ][::std::mem::offset_of!(ip_frag_pkt, lru) - 0usize]; + [ + "Offset of field: ip_frag_pkt::key", + ][::std::mem::offset_of!(ip_frag_pkt, key) - 16usize]; + [ + "Offset of field: ip_frag_pkt::start", + ][::std::mem::offset_of!(ip_frag_pkt, start) - 56usize]; + [ + "Offset of field: ip_frag_pkt::total_size", + ][::std::mem::offset_of!(ip_frag_pkt, total_size) - 64usize]; + [ + "Offset of field: ip_frag_pkt::frag_size", + ][::std::mem::offset_of!(ip_frag_pkt, frag_size) - 68usize]; + [ + "Offset of field: ip_frag_pkt::last_idx", + ][::std::mem::offset_of!(ip_frag_pkt, last_idx) - 72usize]; + [ + "Offset of field: ip_frag_pkt::frags", + ][::std::mem::offset_of!(ip_frag_pkt, frags) - 80usize]; +}; +impl Default for ip_frag_pkt { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ip_pkt_list { + pub tqh_first: *mut ip_frag_pkt, + pub tqh_last: *mut *mut ip_frag_pkt, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ip_pkt_list"][::std::mem::size_of::() - 16usize]; + ["Alignment of ip_pkt_list"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: ip_pkt_list::tqh_first", + ][::std::mem::offset_of!(ip_pkt_list, tqh_first) - 0usize]; + [ + "Offset of field: ip_pkt_list::tqh_last", + ][::std::mem::offset_of!(ip_pkt_list, tqh_last) - 8usize]; +}; +impl Default for ip_pkt_list { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +/// fragmentation table statistics +#[repr(C)] +#[repr(align(64))] +#[derive(Debug, Copy, Clone)] +pub struct ip_frag_tbl_stat { + ///< total # of find/insert attempts. + pub find_num: u64, + ///< # of add ops. + pub add_num: u64, + ///< # of del ops. + pub del_num: u64, + ///< # of reuse (del/add) ops. + pub reuse_num: u64, + ///< total # of add failures. + pub fail_total: u64, + ///< # of 'no space' add failures. + pub fail_nospace: u64, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ip_frag_tbl_stat"][::std::mem::size_of::() - 64usize]; + [ + "Alignment of ip_frag_tbl_stat", + ][::std::mem::align_of::() - 64usize]; + [ + "Offset of field: ip_frag_tbl_stat::find_num", + ][::std::mem::offset_of!(ip_frag_tbl_stat, find_num) - 0usize]; + [ + "Offset of field: ip_frag_tbl_stat::add_num", + ][::std::mem::offset_of!(ip_frag_tbl_stat, add_num) - 8usize]; + [ + "Offset of field: ip_frag_tbl_stat::del_num", + ][::std::mem::offset_of!(ip_frag_tbl_stat, del_num) - 16usize]; + [ + "Offset of field: ip_frag_tbl_stat::reuse_num", + ][::std::mem::offset_of!(ip_frag_tbl_stat, reuse_num) - 24usize]; + [ + "Offset of field: ip_frag_tbl_stat::fail_total", + ][::std::mem::offset_of!(ip_frag_tbl_stat, fail_total) - 32usize]; + [ + "Offset of field: ip_frag_tbl_stat::fail_nospace", + ][::std::mem::offset_of!(ip_frag_tbl_stat, fail_nospace) - 40usize]; +}; +impl Default for ip_frag_tbl_stat { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +/// fragmentation table +#[repr(C)] +#[repr(align(64))] +#[derive(Debug)] +pub struct rte_ip_frag_tbl { + ///< ttl for table entries. + pub max_cycles: u64, + ///< hash value mask. + pub entry_mask: u32, + ///< max entries allowed. + pub max_entries: u32, + ///< entries in use. + pub use_entries: u32, + ///< hash assocaitivity. + pub bucket_entries: u32, + ///< total size of the table. + pub nb_entries: u32, + ///< num of associativity lines. + pub nb_buckets: u32, + ///< last used entry. + pub last: *mut ip_frag_pkt, + ///< LRU list for table entries. + pub lru: ip_pkt_list, + pub __bindgen_padding_0: __BindgenOpaqueArray8<[u8; 8usize]>, + ///< statistics counters. + pub stat: ip_frag_tbl_stat, + ///< hash table. + pub pkt: __IncompleteArrayField, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_ip_frag_tbl"][::std::mem::size_of::() - 128usize]; + [ + "Alignment of rte_ip_frag_tbl", + ][::std::mem::align_of::() - 64usize]; + [ + "Offset of field: rte_ip_frag_tbl::max_cycles", + ][::std::mem::offset_of!(rte_ip_frag_tbl, max_cycles) - 0usize]; + [ + "Offset of field: rte_ip_frag_tbl::entry_mask", + ][::std::mem::offset_of!(rte_ip_frag_tbl, entry_mask) - 8usize]; + [ + "Offset of field: rte_ip_frag_tbl::max_entries", + ][::std::mem::offset_of!(rte_ip_frag_tbl, max_entries) - 12usize]; + [ + "Offset of field: rte_ip_frag_tbl::use_entries", + ][::std::mem::offset_of!(rte_ip_frag_tbl, use_entries) - 16usize]; + [ + "Offset of field: rte_ip_frag_tbl::bucket_entries", + ][::std::mem::offset_of!(rte_ip_frag_tbl, bucket_entries) - 20usize]; + [ + "Offset of field: rte_ip_frag_tbl::nb_entries", + ][::std::mem::offset_of!(rte_ip_frag_tbl, nb_entries) - 24usize]; + [ + "Offset of field: rte_ip_frag_tbl::nb_buckets", + ][::std::mem::offset_of!(rte_ip_frag_tbl, nb_buckets) - 28usize]; + [ + "Offset of field: rte_ip_frag_tbl::last", + ][::std::mem::offset_of!(rte_ip_frag_tbl, last) - 32usize]; + [ + "Offset of field: rte_ip_frag_tbl::lru", + ][::std::mem::offset_of!(rte_ip_frag_tbl, lru) - 40usize]; + [ + "Offset of field: rte_ip_frag_tbl::stat", + ][::std::mem::offset_of!(rte_ip_frag_tbl, stat) - 64usize]; + [ + "Offset of field: rte_ip_frag_tbl::pkt", + ][::std::mem::offset_of!(rte_ip_frag_tbl, pkt) - 128usize]; +}; +impl Default for rte_ip_frag_tbl { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +///< fragment mbuf +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct rte_mbuf { + pub _address: u8, +} diff --git a/bindgen-tests/tests/expectations/tests/layout_mbuf.rs b/bindgen-tests/tests/expectations/tests/layout_mbuf.rs new file mode 100644 index 0000000000..ce6c58e39e --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/layout_mbuf.rs @@ -0,0 +1,1228 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +pub const RTE_CACHE_LINE_MIN_SIZE: u32 = 64; +pub const RTE_CACHE_LINE_SIZE: u32 = 64; +pub type phys_addr_t = u64; +pub type MARKER = [*mut ::std::os::raw::c_void; 0usize]; +pub type MARKER8 = [u8; 0usize]; +pub type MARKER64 = [u64; 0usize]; +/// The atomic counter structure. +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_atomic16_t { + ///< An internal counter value. + pub cnt: i16, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_atomic16_t"][::std::mem::size_of::() - 2usize]; + ["Alignment of rte_atomic16_t"][::std::mem::align_of::() - 2usize]; + [ + "Offset of field: rte_atomic16_t::cnt", + ][::std::mem::offset_of!(rte_atomic16_t, cnt) - 0usize]; +}; +/// The generic rte_mbuf, containing a packet mbuf. +#[repr(C)] +#[repr(align(64))] +pub struct rte_mbuf { + pub cacheline0: MARKER, + ///< Virtual address of segment buffer. + pub buf_addr: *mut ::std::os::raw::c_void, + ///< Physical address of segment buffer. + pub buf_physaddr: phys_addr_t, + ///< Length of segment buffer. + pub buf_len: u16, + pub rearm_data: MARKER8, + pub data_off: u16, + pub __bindgen_anon_1: rte_mbuf__bindgen_ty_1, + ///< Number of segments. + pub nb_segs: u8, + ///< Input port. + pub port: u8, + ///< Offload features. + pub ol_flags: u64, + pub rx_descriptor_fields1: MARKER, + pub __bindgen_anon_2: rte_mbuf__bindgen_ty_2, + ///< Total pkt len: sum of all segments. + pub pkt_len: u32, + ///< Amount of data in segment buffer. + pub data_len: u16, + /// VLAN TCI (CPU order), valid if PKT_RX_VLAN_STRIPPED is set. + pub vlan_tci: u16, + ///< hash information + pub hash: rte_mbuf__bindgen_ty_3, + ///< Sequence number. See also rte_reorder_insert() + pub seqn: u32, + /// Outer VLAN TCI (CPU order), valid if PKT_RX_QINQ_STRIPPED is set. + pub vlan_tci_outer: u16, + pub cacheline1: MARKER, + pub __bindgen_anon_3: rte_mbuf__bindgen_ty_4, + ///< Pool from which mbuf was allocated. + pub pool: *mut rte_mempool, + ///< Next segment of scattered packet. + pub next: *mut rte_mbuf, + pub __bindgen_anon_4: rte_mbuf__bindgen_ty_5, + /** Size of the application private data. In case of an indirect + mbuf, it stores the direct mbuf private data size.*/ + pub priv_size: u16, + /// Timesync flags for use with IEEE1588. + pub timesync: u16, +} +/** 16-bit Reference counter. + It should only be accessed using the following functions: + rte_mbuf_refcnt_update(), rte_mbuf_refcnt_read(), and + rte_mbuf_refcnt_set(). The functionality of these functions (atomic, + or non-atomic) is controlled by the CONFIG_RTE_MBUF_REFCNT_ATOMIC + config option.*/ +#[repr(C)] +#[derive(Copy, Clone)] +pub union rte_mbuf__bindgen_ty_1 { + ///< Atomically accessed refcnt + pub refcnt_atomic: rte_atomic16_t, + ///< Non-atomically accessed refcnt + pub refcnt: u16, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_mbuf__bindgen_ty_1", + ][::std::mem::size_of::() - 2usize]; + [ + "Alignment of rte_mbuf__bindgen_ty_1", + ][::std::mem::align_of::() - 2usize]; + [ + "Offset of field: rte_mbuf__bindgen_ty_1::refcnt_atomic", + ][::std::mem::offset_of!(rte_mbuf__bindgen_ty_1, refcnt_atomic) - 0usize]; + [ + "Offset of field: rte_mbuf__bindgen_ty_1::refcnt", + ][::std::mem::offset_of!(rte_mbuf__bindgen_ty_1, refcnt) - 0usize]; +}; +impl Default for rte_mbuf__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union rte_mbuf__bindgen_ty_2 { + ///< L2/L3/L4 and tunnel information. + pub packet_type: u32, + pub __bindgen_anon_1: rte_mbuf__bindgen_ty_2__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_mbuf__bindgen_ty_2__bindgen_ty_1 { + pub _bindgen_align: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_mbuf__bindgen_ty_2__bindgen_ty_1", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of rte_mbuf__bindgen_ty_2__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; +}; +impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 { + #[inline] + pub fn l2_type(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } + } + #[inline] + pub fn set_l2_type(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn l2_type_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 4u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_l2_type_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn l3_type(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32) } + } + #[inline] + pub fn set_l3_type(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn l3_type_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 4u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_l3_type_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn l4_type(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u32) } + } + #[inline] + pub fn set_l4_type(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn l4_type_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 8usize, 4u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_l4_type_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn tun_type(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u32) } + } + #[inline] + pub fn set_tun_type(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn tun_type_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 12usize, 4u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_tun_type_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 12usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn inner_l2_type(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 4u8) as u32) } + } + #[inline] + pub fn set_inner_l2_type(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn inner_l2_type_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 16usize, 4u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_inner_l2_type_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn inner_l3_type(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 4u8) as u32) } + } + #[inline] + pub fn set_inner_l3_type(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn inner_l3_type_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 20usize, 4u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_inner_l3_type_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 20usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn inner_l4_type(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 4u8) as u32) } + } + #[inline] + pub fn set_inner_l4_type(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn inner_l4_type_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 24usize, 4u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_inner_l4_type_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + l2_type: u32, + l3_type: u32, + l4_type: u32, + tun_type: u32, + inner_l2_type: u32, + inner_l3_type: u32, + inner_l4_type: u32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 4u8, + { + let l2_type: u32 = unsafe { ::std::mem::transmute(l2_type) }; + l2_type as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 4usize, + 4u8, + { + let l3_type: u32 = unsafe { ::std::mem::transmute(l3_type) }; + l3_type as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 8usize, + 4u8, + { + let l4_type: u32 = unsafe { ::std::mem::transmute(l4_type) }; + l4_type as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 12usize, + 4u8, + { + let tun_type: u32 = unsafe { ::std::mem::transmute(tun_type) }; + tun_type as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 16usize, + 4u8, + { + let inner_l2_type: u32 = unsafe { + ::std::mem::transmute(inner_l2_type) + }; + inner_l2_type as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 20usize, + 4u8, + { + let inner_l3_type: u32 = unsafe { + ::std::mem::transmute(inner_l3_type) + }; + inner_l3_type as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 24usize, + 4u8, + { + let inner_l4_type: u32 = unsafe { + ::std::mem::transmute(inner_l4_type) + }; + inner_l4_type as u64 + }, + ); + __bindgen_bitfield_unit + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_mbuf__bindgen_ty_2", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of rte_mbuf__bindgen_ty_2", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_mbuf__bindgen_ty_2::packet_type", + ][::std::mem::offset_of!(rte_mbuf__bindgen_ty_2, packet_type) - 0usize]; +}; +impl Default for rte_mbuf__bindgen_ty_2 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union rte_mbuf__bindgen_ty_3 { + ///< RSS hash result if RSS enabled + pub rss: u32, + ///< Filter identifier if FDIR enabled + pub fdir: rte_mbuf__bindgen_ty_3__bindgen_ty_1, + ///< Hierarchical scheduler + pub sched: rte_mbuf__bindgen_ty_3__bindgen_ty_2, + ///< User defined tags. See rte_distributor_process() + pub usr: u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct rte_mbuf__bindgen_ty_3__bindgen_ty_1 { + pub __bindgen_anon_1: rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1, + pub hi: u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1 { + pub __bindgen_anon_1: rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + pub lo: u32, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 { + pub hash: u16, + pub id: u16, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1", + ][::std::mem::size_of::< + rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >() - 4usize]; + [ + "Alignment of rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1", + ][::std::mem::align_of::< + rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, + >() - 2usize]; + [ + "Offset of field: rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::hash", + ][::std::mem::offset_of!( + rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, hash + ) - 0usize]; + [ + "Offset of field: rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::id", + ][::std::mem::offset_of!( + rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, id + ) - 2usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1", + ][::std::mem::size_of::() + - 4usize]; + [ + "Alignment of rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1", + ][::std::mem::align_of::() + - 4usize]; + [ + "Offset of field: rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1::lo", + ][::std::mem::offset_of!(rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1, lo) + - 0usize]; +}; +impl Default for rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_mbuf__bindgen_ty_3__bindgen_ty_1", + ][::std::mem::size_of::() - 8usize]; + [ + "Alignment of rte_mbuf__bindgen_ty_3__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_mbuf__bindgen_ty_3__bindgen_ty_1::hi", + ][::std::mem::offset_of!(rte_mbuf__bindgen_ty_3__bindgen_ty_1, hi) - 4usize]; +}; +impl Default for rte_mbuf__bindgen_ty_3__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_mbuf__bindgen_ty_3__bindgen_ty_2 { + pub lo: u32, + pub hi: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_mbuf__bindgen_ty_3__bindgen_ty_2", + ][::std::mem::size_of::() - 8usize]; + [ + "Alignment of rte_mbuf__bindgen_ty_3__bindgen_ty_2", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_mbuf__bindgen_ty_3__bindgen_ty_2::lo", + ][::std::mem::offset_of!(rte_mbuf__bindgen_ty_3__bindgen_ty_2, lo) - 0usize]; + [ + "Offset of field: rte_mbuf__bindgen_ty_3__bindgen_ty_2::hi", + ][::std::mem::offset_of!(rte_mbuf__bindgen_ty_3__bindgen_ty_2, hi) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_mbuf__bindgen_ty_3", + ][::std::mem::size_of::() - 8usize]; + [ + "Alignment of rte_mbuf__bindgen_ty_3", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: rte_mbuf__bindgen_ty_3::rss", + ][::std::mem::offset_of!(rte_mbuf__bindgen_ty_3, rss) - 0usize]; + [ + "Offset of field: rte_mbuf__bindgen_ty_3::fdir", + ][::std::mem::offset_of!(rte_mbuf__bindgen_ty_3, fdir) - 0usize]; + [ + "Offset of field: rte_mbuf__bindgen_ty_3::sched", + ][::std::mem::offset_of!(rte_mbuf__bindgen_ty_3, sched) - 0usize]; + [ + "Offset of field: rte_mbuf__bindgen_ty_3::usr", + ][::std::mem::offset_of!(rte_mbuf__bindgen_ty_3, usr) - 0usize]; +}; +impl Default for rte_mbuf__bindgen_ty_3 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union rte_mbuf__bindgen_ty_4 { + ///< Can be used for external metadata + pub userdata: *mut ::std::os::raw::c_void, + ///< Allow 8-byte userdata on 32-bit + pub udata64: u64, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_mbuf__bindgen_ty_4", + ][::std::mem::size_of::() - 8usize]; + [ + "Alignment of rte_mbuf__bindgen_ty_4", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: rte_mbuf__bindgen_ty_4::userdata", + ][::std::mem::offset_of!(rte_mbuf__bindgen_ty_4, userdata) - 0usize]; + [ + "Offset of field: rte_mbuf__bindgen_ty_4::udata64", + ][::std::mem::offset_of!(rte_mbuf__bindgen_ty_4, udata64) - 0usize]; +}; +impl Default for rte_mbuf__bindgen_ty_4 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union rte_mbuf__bindgen_ty_5 { + ///< combined for easy fetch + pub tx_offload: u64, + pub __bindgen_anon_1: rte_mbuf__bindgen_ty_5__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_mbuf__bindgen_ty_5__bindgen_ty_1 { + pub _bindgen_align: [u64; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 7usize]>, + pub __bindgen_padding_0: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_mbuf__bindgen_ty_5__bindgen_ty_1", + ][::std::mem::size_of::() - 8usize]; + [ + "Alignment of rte_mbuf__bindgen_ty_5__bindgen_ty_1", + ][::std::mem::align_of::() - 8usize]; +}; +impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 { + #[inline] + pub fn l2_len(&self) -> u64 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 7u8) as u64) } + } + #[inline] + pub fn set_l2_len(&mut self, val: u64) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 7u8, val as u64) + } + } + #[inline] + pub unsafe fn l2_len_raw(this: *const Self) -> u64 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 7usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 7u8) + as u64, + ) + } + } + #[inline] + pub unsafe fn set_l2_len_raw(this: *mut Self, val: u64) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 7usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 7u8, + val as u64, + ) + } + } + #[inline] + pub fn l3_len(&self) -> u64 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 9u8) as u64) } + } + #[inline] + pub fn set_l3_len(&mut self, val: u64) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn l3_len_raw(this: *const Self) -> u64 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 7usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 7usize, 9u8) + as u64, + ) + } + } + #[inline] + pub unsafe fn set_l3_len_raw(this: *mut Self, val: u64) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 7usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn l4_len(&self) -> u64 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u64) } + } + #[inline] + pub fn set_l4_len(&mut self, val: u64) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn l4_len_raw(this: *const Self) -> u64 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 7usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 16usize, 8u8) + as u64, + ) + } + } + #[inline] + pub unsafe fn set_l4_len_raw(this: *mut Self, val: u64) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 7usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn tso_segsz(&self) -> u64 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 16u8) as u64) } + } + #[inline] + pub fn set_tso_segsz(&mut self, val: u64) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 16u8, val as u64) + } + } + #[inline] + pub unsafe fn tso_segsz_raw(this: *const Self) -> u64 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 7usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 24usize, 16u8) + as u64, + ) + } + } + #[inline] + pub unsafe fn set_tso_segsz_raw(this: *mut Self, val: u64) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 7usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 16u8, + val as u64, + ) + } + } + #[inline] + pub fn outer_l3_len(&self) -> u64 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 9u8) as u64) } + } + #[inline] + pub fn set_outer_l3_len(&mut self, val: u64) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + self._bitfield_1.set(40usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn outer_l3_len_raw(this: *const Self) -> u64 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 7usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 40usize, 9u8) + as u64, + ) + } + } + #[inline] + pub unsafe fn set_outer_l3_len_raw(this: *mut Self, val: u64) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 7usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 40usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn outer_l2_len(&self) -> u64 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(49usize, 7u8) as u64) } + } + #[inline] + pub fn set_outer_l2_len(&mut self, val: u64) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + self._bitfield_1.set(49usize, 7u8, val as u64) + } + } + #[inline] + pub unsafe fn outer_l2_len_raw(this: *const Self) -> u64 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 7usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 49usize, 7u8) + as u64, + ) + } + } + #[inline] + pub unsafe fn set_outer_l2_len_raw(this: *mut Self, val: u64) { + unsafe { + let val: u64 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 7usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 49usize, + 7u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + l2_len: u64, + l3_len: u64, + l4_len: u64, + tso_segsz: u64, + outer_l3_len: u64, + outer_l2_len: u64, + ) -> __BindgenBitfieldUnit<[u8; 7usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 7usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 7u8, + { + let l2_len: u64 = unsafe { ::std::mem::transmute(l2_len) }; + l2_len as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 7usize, + 9u8, + { + let l3_len: u64 = unsafe { ::std::mem::transmute(l3_len) }; + l3_len as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 16usize, + 8u8, + { + let l4_len: u64 = unsafe { ::std::mem::transmute(l4_len) }; + l4_len as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 24usize, + 16u8, + { + let tso_segsz: u64 = unsafe { ::std::mem::transmute(tso_segsz) }; + tso_segsz as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 40usize, + 9u8, + { + let outer_l3_len: u64 = unsafe { + ::std::mem::transmute(outer_l3_len) + }; + outer_l3_len as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 49usize, + 7u8, + { + let outer_l2_len: u64 = unsafe { + ::std::mem::transmute(outer_l2_len) + }; + outer_l2_len as u64 + }, + ); + __bindgen_bitfield_unit + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of rte_mbuf__bindgen_ty_5", + ][::std::mem::size_of::() - 8usize]; + [ + "Alignment of rte_mbuf__bindgen_ty_5", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: rte_mbuf__bindgen_ty_5::tx_offload", + ][::std::mem::offset_of!(rte_mbuf__bindgen_ty_5, tx_offload) - 0usize]; +}; +impl Default for rte_mbuf__bindgen_ty_5 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of rte_mbuf"][::std::mem::size_of::() - 128usize]; + ["Alignment of rte_mbuf"][::std::mem::align_of::() - 64usize]; + [ + "Offset of field: rte_mbuf::cacheline0", + ][::std::mem::offset_of!(rte_mbuf, cacheline0) - 0usize]; + [ + "Offset of field: rte_mbuf::buf_addr", + ][::std::mem::offset_of!(rte_mbuf, buf_addr) - 0usize]; + [ + "Offset of field: rte_mbuf::buf_physaddr", + ][::std::mem::offset_of!(rte_mbuf, buf_physaddr) - 8usize]; + [ + "Offset of field: rte_mbuf::buf_len", + ][::std::mem::offset_of!(rte_mbuf, buf_len) - 16usize]; + [ + "Offset of field: rte_mbuf::rearm_data", + ][::std::mem::offset_of!(rte_mbuf, rearm_data) - 18usize]; + [ + "Offset of field: rte_mbuf::data_off", + ][::std::mem::offset_of!(rte_mbuf, data_off) - 18usize]; + [ + "Offset of field: rte_mbuf::nb_segs", + ][::std::mem::offset_of!(rte_mbuf, nb_segs) - 22usize]; + [ + "Offset of field: rte_mbuf::port", + ][::std::mem::offset_of!(rte_mbuf, port) - 23usize]; + [ + "Offset of field: rte_mbuf::ol_flags", + ][::std::mem::offset_of!(rte_mbuf, ol_flags) - 24usize]; + [ + "Offset of field: rte_mbuf::rx_descriptor_fields1", + ][::std::mem::offset_of!(rte_mbuf, rx_descriptor_fields1) - 32usize]; + [ + "Offset of field: rte_mbuf::pkt_len", + ][::std::mem::offset_of!(rte_mbuf, pkt_len) - 36usize]; + [ + "Offset of field: rte_mbuf::data_len", + ][::std::mem::offset_of!(rte_mbuf, data_len) - 40usize]; + [ + "Offset of field: rte_mbuf::vlan_tci", + ][::std::mem::offset_of!(rte_mbuf, vlan_tci) - 42usize]; + [ + "Offset of field: rte_mbuf::hash", + ][::std::mem::offset_of!(rte_mbuf, hash) - 44usize]; + [ + "Offset of field: rte_mbuf::seqn", + ][::std::mem::offset_of!(rte_mbuf, seqn) - 52usize]; + [ + "Offset of field: rte_mbuf::vlan_tci_outer", + ][::std::mem::offset_of!(rte_mbuf, vlan_tci_outer) - 56usize]; + [ + "Offset of field: rte_mbuf::cacheline1", + ][::std::mem::offset_of!(rte_mbuf, cacheline1) - 64usize]; + [ + "Offset of field: rte_mbuf::pool", + ][::std::mem::offset_of!(rte_mbuf, pool) - 72usize]; + [ + "Offset of field: rte_mbuf::next", + ][::std::mem::offset_of!(rte_mbuf, next) - 80usize]; + [ + "Offset of field: rte_mbuf::priv_size", + ][::std::mem::offset_of!(rte_mbuf, priv_size) - 96usize]; + [ + "Offset of field: rte_mbuf::timesync", + ][::std::mem::offset_of!(rte_mbuf, timesync) - 98usize]; +}; +impl Default for rte_mbuf { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +///< Pool from which mbuf was allocated. +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct rte_mempool { + pub _address: u8, +} diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/atomic-constant.rs b/bindgen-tests/tests/expectations/tests/libclang-9/atomic-constant.rs new file mode 100644 index 0000000000..098beb43de --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/libclang-9/atomic-constant.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub static mut b: ::std::os::raw::c_int; +} diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/constified-enum-module-overflow.rs b/bindgen-tests/tests/expectations/tests/libclang-9/constified-enum-module-overflow.rs new file mode 100644 index 0000000000..4f8296c65c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/libclang-9/constified-enum-module-overflow.rs @@ -0,0 +1,32 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct B { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct C { + pub _address: u8, +} +pub type C_U = B; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct A { + pub u: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A"][::std::mem::size_of::() - 1usize]; + ["Alignment of A"][::std::mem::align_of::() - 1usize]; + ["Offset of field: A::u"][::std::mem::offset_of!(A, u) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: C_open0_A_close0", + ][::std::mem::size_of::() - 1usize]; + [ + "Align of template specialization: C_open0_A_close0", + ][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/issue-544-stylo-creduce-2.rs b/bindgen-tests/tests/expectations/tests/libclang-9/issue-544-stylo-creduce-2.rs new file mode 100644 index 0000000000..d64a8948ee --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/libclang-9/issue-544-stylo-creduce-2.rs @@ -0,0 +1,25 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)] +#[repr(C)] +pub struct __BindgenOpaqueArray(pub T); +impl Default for __BindgenOpaqueArray<[T; N]> { + fn default() -> Self { + Self([::default(); N]) + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Foo { + pub member: *mut __BindgenOpaqueArray<[u8; 0usize]>, +} +pub type Foo_FirstAlias = __BindgenOpaqueArray<[u8; 0usize]>; +pub type Foo_SecondAlias = __BindgenOpaqueArray<[u8; 0usize]>; +impl Default for Foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/issue-753.rs b/bindgen-tests/tests/expectations/tests/libclang-9/issue-753.rs new file mode 100644 index 0000000000..fe64295a68 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/libclang-9/issue-753.rs @@ -0,0 +1 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] \ No newline at end of file diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/macro_fallback_non_system_dir.rs b/bindgen-tests/tests/expectations/tests/libclang-9/macro_fallback_non_system_dir.rs new file mode 100644 index 0000000000..8f5c4ba2da --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/libclang-9/macro_fallback_non_system_dir.rs @@ -0,0 +1 @@ +pub const NEGATIVE: i32 = -1; diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/ptr32-has-different-size.rs b/bindgen-tests/tests/expectations/tests/libclang-9/ptr32-has-different-size.rs new file mode 100644 index 0000000000..f55f88f496 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/libclang-9/ptr32-has-different-size.rs @@ -0,0 +1,24 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct TEST_STRUCT { + pub ptr_32bit: *mut ::std::os::raw::c_void, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of TEST_STRUCT"][::std::mem::size_of::() - 8usize]; + ["Alignment of TEST_STRUCT"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: TEST_STRUCT::ptr_32bit", + ][::std::mem::offset_of!(TEST_STRUCT, ptr_32bit) - 0usize]; +}; +impl Default for TEST_STRUCT { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type TEST = TEST_STRUCT; diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/struct_typedef_ns.rs b/bindgen-tests/tests/expectations/tests/libclang-9/struct_typedef_ns.rs new file mode 100644 index 0000000000..d93a62e746 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/libclang-9/struct_typedef_ns.rs @@ -0,0 +1,57 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod whatever { + #[allow(unused_imports)] + use self::super::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] + pub struct typedef_struct { + pub foo: ::std::os::raw::c_int, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of typedef_struct"][::std::mem::size_of::() - 4usize]; + [ + "Alignment of typedef_struct", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: typedef_struct::foo", + ][::std::mem::offset_of!(typedef_struct, foo) - 0usize]; + }; + #[repr(u32)] + #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] + pub enum typedef_enum { + BAR = 1, + } + } + pub mod _bindgen_mod_id_12 { + #[allow(unused_imports)] + use self::super::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] + pub struct _bindgen_ty_1 { + pub foo: ::std::os::raw::c_int, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of _bindgen_ty_1"][::std::mem::size_of::<_bindgen_ty_1>() - 4usize]; + [ + "Alignment of _bindgen_ty_1", + ][::std::mem::align_of::<_bindgen_ty_1>() - 4usize]; + [ + "Offset of field: _bindgen_ty_1::foo", + ][::std::mem::offset_of!(_bindgen_ty_1, foo) - 0usize]; + }; + pub type typedef_struct = root::_bindgen_mod_id_12::_bindgen_ty_1; + pub const _bindgen_mod_id_12_BAR: root::_bindgen_mod_id_12::_bindgen_ty_2 = _bindgen_ty_2::BAR; + #[repr(u32)] + #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] + pub enum _bindgen_ty_2 { + BAR = 1, + } + pub use self::super::super::root::_bindgen_mod_id_12::_bindgen_ty_2 as typedef_enum; + } +} diff --git a/bindgen-tests/tests/expectations/tests/libclang_version_specific_generated_tests.rs b/bindgen-tests/tests/expectations/tests/libclang_version_specific_generated_tests.rs new file mode 100644 index 0000000000..2643709c04 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/libclang_version_specific_generated_tests.rs @@ -0,0 +1,4 @@ +include!(concat!( + env!("OUT_DIR"), + "/libclang_version_specific_generated_tests.rs" +)); diff --git a/bindgen-tests/tests/expectations/tests/long_double.rs b/bindgen-tests/tests/expectations/tests/long_double.rs new file mode 100644 index 0000000000..4a8b13e9b0 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/long_double.rs @@ -0,0 +1,13 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct foo { + pub bar: u128, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 16usize]; + ["Alignment of foo"][::std::mem::align_of::() - 16usize]; + ["Offset of field: foo::bar"][::std::mem::offset_of!(foo, bar) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/macro-expr-basic.rs b/bindgen-tests/tests/expectations/tests/macro-expr-basic.rs new file mode 100644 index 0000000000..21c81b317c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/macro-expr-basic.rs @@ -0,0 +1,10 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const FOO: u32 = 1; +pub const BAR: u32 = 4; +pub const BAZ: u32 = 5; +pub const MIN: i64 = -9223372036854775808; +pub const BARR: u32 = 1; +pub const BAZZ: u32 = 7; +pub const I_RAN_OUT_OF_DUMB_NAMES: u32 = 7; +pub const HAZ_A_COMMENT: u32 = 1; +pub const HAZ_A_COMMENT_INSIDE: u32 = 2; diff --git a/bindgen-tests/tests/expectations/tests/macro-expr-uncommon-token.rs b/bindgen-tests/tests/expectations/tests/macro-expr-uncommon-token.rs new file mode 100644 index 0000000000..785ef4bb9f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/macro-expr-uncommon-token.rs @@ -0,0 +1,5 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const MODBUS_WOOT: u32 = 3; +unsafe extern "C" { + pub fn foo(); +} diff --git a/bindgen-tests/tests/expectations/tests/macro-redef.rs b/bindgen-tests/tests/expectations/tests/macro-redef.rs new file mode 100644 index 0000000000..12e3d3d587 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/macro-redef.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const FOO: u32 = 4; +pub const BAR: u32 = 5; +pub const BAZ: u32 = 6; diff --git a/bindgen-tests/tests/expectations/tests/macro_const.rs b/bindgen-tests/tests/expectations/tests/macro_const.rs new file mode 100644 index 0000000000..e4e27dea52 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/macro_const.rs @@ -0,0 +1,8 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const foo: &[u8; 4] = b"bar\0"; +pub const CHAR: u8 = 98u8; +pub const CHARR: u8 = 0u8; +pub const FLOAT: f64 = 5.09; +pub const FLOAT_EXPR: f64 = 0.005; +pub const LONG: u32 = 3; +pub const INVALID_UTF8: &[u8; 5] = b"\xF0(\x8C(\0"; diff --git a/bindgen-tests/tests/expectations/tests/maddness-is-avoidable.rs b/bindgen-tests/tests/expectations/tests/maddness-is-avoidable.rs new file mode 100644 index 0000000000..0876aeb904 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/maddness-is-avoidable.rs @@ -0,0 +1,11 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct RefPtr { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct RefPtr_Proxy { + pub _address: u8, +} diff --git a/bindgen-tests/tests/expectations/tests/mangling-ios.rs b/bindgen-tests/tests/expectations/tests/mangling-ios.rs new file mode 100644 index 0000000000..736d379f01 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/mangling-ios.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn foo(); +} diff --git a/bindgen-tests/tests/expectations/tests/mangling-linux32.rs b/bindgen-tests/tests/expectations/tests/mangling-linux32.rs new file mode 100644 index 0000000000..b6ed9146da --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/mangling-linux32.rs @@ -0,0 +1,18 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn foo(); +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN3Foo4sBarE"] + pub static mut Foo_sBar: bool; +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/mangling-linux64.rs b/bindgen-tests/tests/expectations/tests/mangling-linux64.rs new file mode 100644 index 0000000000..b6ed9146da --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/mangling-linux64.rs @@ -0,0 +1,18 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn foo(); +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN3Foo4sBarE"] + pub static mut Foo_sBar: bool; +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/mangling-macos.rs b/bindgen-tests/tests/expectations/tests/mangling-macos.rs new file mode 100644 index 0000000000..237859e23b --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/mangling-macos.rs @@ -0,0 +1,18 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn foo(); +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +unsafe extern "C" { + #[link_name = "\u{1}__ZN3Foo4sBarE"] + pub static mut Foo_sBar: bool; +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/mangling-win32.rs b/bindgen-tests/tests/expectations/tests/mangling-win32.rs new file mode 100644 index 0000000000..263f619374 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/mangling-win32.rs @@ -0,0 +1,39 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target = "i686-pc-windows-msvc")] +unsafe extern "C" { + pub fn foo(); +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +unsafe extern "C" { + #[link_name = "\u{1}?sBar@Foo@@2_NA"] + pub static mut Foo_sBar: bool; +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "fastcall" { + pub fn fast_call_func_no_args() -> ::std::os::raw::c_int; +} +unsafe extern "fastcall" { + pub fn fast_call_func_many_args( + arg1: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "stdcall" { + pub fn std_call_func_no_args() -> ::std::os::raw::c_int; +} +unsafe extern "stdcall" { + pub fn std_call_func_many_args( + arg1: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} diff --git a/bindgen-tests/tests/expectations/tests/mangling-win64.rs b/bindgen-tests/tests/expectations/tests/mangling-win64.rs new file mode 100644 index 0000000000..2a782480ed --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/mangling-win64.rs @@ -0,0 +1,18 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn foo(); +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +unsafe extern "C" { + #[link_name = "\u{1}?sBar@Foo@@2_NA"] + pub static mut Foo_sBar: bool; +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/merge_extern_blocks_post_1_82.rs b/bindgen-tests/tests/expectations/tests/merge_extern_blocks_post_1_82.rs new file mode 100644 index 0000000000..98659f6382 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/merge_extern_blocks_post_1_82.rs @@ -0,0 +1,44 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Point { + pub x: ::std::os::raw::c_int, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Point"][::std::mem::size_of::() - 4usize]; + ["Alignment of Point"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Point::x"][::std::mem::offset_of!(Point, x) - 0usize]; + }; + pub mod ns { + #[allow(unused_imports)] + use self::super::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Point { + pub x: ::std::os::raw::c_int, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Point"][::std::mem::size_of::() - 4usize]; + ["Alignment of Point"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Point::x"][::std::mem::offset_of!(Point, x) - 0usize]; + }; + unsafe extern "C" { + #[link_name = "\u{1}_ZN2ns3fooEv"] + pub fn foo() -> ::std::os::raw::c_int; + #[link_name = "\u{1}_ZN2ns3barEv"] + pub fn bar() -> ::std::os::raw::c_int; + } + } + unsafe extern "C" { + #[link_name = "\u{1}_Z3foov"] + pub fn foo() -> ::std::os::raw::c_int; + #[link_name = "\u{1}_Z3barv"] + pub fn bar() -> ::std::os::raw::c_int; + } +} diff --git a/bindgen-tests/tests/expectations/tests/merge_extern_blocks_pre_1_82.rs b/bindgen-tests/tests/expectations/tests/merge_extern_blocks_pre_1_82.rs new file mode 100644 index 0000000000..595d865af1 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/merge_extern_blocks_pre_1_82.rs @@ -0,0 +1,44 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Point { + pub x: ::std::os::raw::c_int, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Point"][::std::mem::size_of::() - 4usize]; + ["Alignment of Point"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Point::x"][::std::mem::offset_of!(Point, x) - 0usize]; + }; + pub mod ns { + #[allow(unused_imports)] + use self::super::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Point { + pub x: ::std::os::raw::c_int, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Point"][::std::mem::size_of::() - 4usize]; + ["Alignment of Point"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Point::x"][::std::mem::offset_of!(Point, x) - 0usize]; + }; + extern "C" { + #[link_name = "\u{1}_ZN2ns3fooEv"] + pub fn foo() -> ::std::os::raw::c_int; + #[link_name = "\u{1}_ZN2ns3barEv"] + pub fn bar() -> ::std::os::raw::c_int; + } + } + extern "C" { + #[link_name = "\u{1}_Z3foov"] + pub fn foo() -> ::std::os::raw::c_int; + #[link_name = "\u{1}_Z3barv"] + pub fn bar() -> ::std::os::raw::c_int; + } +} diff --git a/bindgen-tests/tests/expectations/tests/method-mangling.rs b/bindgen-tests/tests/expectations/tests/method-mangling.rs new file mode 100644 index 0000000000..4c86825cce --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/method-mangling.rs @@ -0,0 +1,21 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN3Foo4typeEv"] + pub fn Foo_type(this: *mut Foo) -> ::std::os::raw::c_int; +} +impl Foo { + #[inline] + pub unsafe fn type_(&mut self) -> ::std::os::raw::c_int { + Foo_type(self) + } +} diff --git a/bindgen-tests/tests/expectations/tests/module-allowlisted.rs b/bindgen-tests/tests/expectations/tests/module-allowlisted.rs new file mode 100644 index 0000000000..9ac408dc8f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/module-allowlisted.rs @@ -0,0 +1,16 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Test { + pub _address: u8, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Test"][::std::mem::size_of::() - 1usize]; + ["Alignment of Test"][::std::mem::align_of::() - 1usize]; + }; +} diff --git a/bindgen-tests/tests/expectations/tests/msvc-no-usr.rs b/bindgen-tests/tests/expectations/tests/msvc-no-usr.rs new file mode 100644 index 0000000000..adaa1a07b2 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/msvc-no-usr.rs @@ -0,0 +1,12 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct A { + pub foo: usize, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A"][::std::mem::size_of::() - 8usize]; + ["Alignment of A"][::std::mem::align_of::() - 8usize]; + ["Offset of field: A::foo"][::std::mem::offset_of!(A, foo) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/multiple-inherit-empty-correct-layout.rs b/bindgen-tests/tests/expectations/tests/multiple-inherit-empty-correct-layout.rs new file mode 100644 index 0000000000..b0cf27451c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/multiple-inherit-empty-correct-layout.rs @@ -0,0 +1,31 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Bar { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 1usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Baz { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Baz"][::std::mem::size_of::() - 1usize]; + ["Alignment of Baz"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/mutable.rs b/bindgen-tests/tests/expectations/tests/mutable.rs new file mode 100644 index 0000000000..ff98d31f24 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/mutable.rs @@ -0,0 +1,45 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct C { + pub m_member: ::std::os::raw::c_int, + pub m_other: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C"][::std::mem::size_of::() - 8usize]; + ["Alignment of C"][::std::mem::align_of::() - 4usize]; + ["Offset of field: C::m_member"][::std::mem::offset_of!(C, m_member) - 0usize]; + ["Offset of field: C::m_other"][::std::mem::offset_of!(C, m_other) - 4usize]; +}; +#[repr(C)] +#[derive(Debug, Default)] +pub struct NonCopiable { + pub m_member: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of NonCopiable"][::std::mem::size_of::() - 4usize]; + ["Alignment of NonCopiable"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: NonCopiable::m_member", + ][::std::mem::offset_of!(NonCopiable, m_member) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Default)] +pub struct NonCopiableWithNonCopiableMutableMember { + pub m_member: NonCopiable, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of NonCopiableWithNonCopiableMutableMember", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of NonCopiableWithNonCopiableMutableMember", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: NonCopiableWithNonCopiableMutableMember::m_member", + ][::std::mem::offset_of!(NonCopiableWithNonCopiableMutableMember, m_member) + - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/namespace.rs b/bindgen-tests/tests/expectations/tests/namespace.rs new file mode 100644 index 0000000000..4e58fa7ab1 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/namespace.rs @@ -0,0 +1,101 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + unsafe extern "C" { + #[link_name = "\u{1}_Z9top_levelv"] + pub fn top_level(); + } + pub mod whatever { + #[allow(unused_imports)] + use self::super::super::root; + pub type whatever_other_thing_t = whatever_int_t; + pub type whatever_int_t = ::std::os::raw::c_int; + unsafe extern "C" { + #[link_name = "\u{1}_ZN8whatever11in_whateverEv"] + pub fn in_whatever(); + } + } + pub mod _bindgen_mod_id_17 { + #[allow(unused_imports)] + use self::super::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct A { + pub b: root::whatever::whatever_int_t, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of A"][::std::mem::size_of::() - 4usize]; + ["Alignment of A"][::std::mem::align_of::() - 4usize]; + ["Offset of field: A::b"][::std::mem::offset_of!(A, b) - 0usize]; + }; + } + #[repr(C)] + #[derive(Debug)] + pub struct C { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub _base: root::_bindgen_mod_id_17::A, + pub m_c: T, + pub m_c_ptr: *mut T, + pub m_c_arr: [T; 10usize], + } + impl Default for C { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } + } + pub mod w { + #[allow(unused_imports)] + use self::super::super::root; + pub type whatever_int_t = ::std::os::raw::c_uint; + #[repr(C)] + #[derive(Debug)] + pub struct D { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub m_c: root::C, + } + impl Default for D { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } + } + unsafe extern "C" { + #[link_name = "\u{1}_ZN1w3hehEv"] + pub fn heh() -> root::w::whatever_int_t; + } + unsafe extern "C" { + #[link_name = "\u{1}_ZN1w3fooEv"] + pub fn foo() -> root::C<::std::os::raw::c_int>; + } + unsafe extern "C" { + #[link_name = "\u{1}_ZN1w4barrEv"] + pub fn barr() -> root::C; + } + } + pub mod foobar { + #[allow(unused_imports)] + use self::super::super::root; + unsafe extern "C" { + #[link_name = "\u{1}_ZN6foobar3fooEv"] + pub fn foo(); + } + } + pub mod faraway { + #[allow(unused_imports)] + use self::super::super::root; + unsafe extern "C" { + #[link_name = "\u{1}_ZN7faraway3barEv"] + pub fn bar(); + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/nested-class-field.rs b/bindgen-tests/tests/expectations/tests/nested-class-field.rs new file mode 100644 index 0000000000..91500f4142 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/nested-class-field.rs @@ -0,0 +1,22 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct A { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A"][::std::mem::size_of::() - 1usize]; + ["Alignment of A"][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct A_I { + pub i: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A_I"][::std::mem::size_of::() - 4usize]; + ["Alignment of A_I"][::std::mem::align_of::() - 4usize]; + ["Offset of field: A_I::i"][::std::mem::offset_of!(A_I, i) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/nested-template-typedef.rs b/bindgen-tests/tests/expectations/tests/nested-template-typedef.rs new file mode 100644 index 0000000000..4a4dd2ffe1 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/nested-template-typedef.rs @@ -0,0 +1,11 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo_Bar { + pub _address: u8, +} diff --git a/bindgen-tests/tests/expectations/tests/nested.rs b/bindgen-tests/tests/expectations/tests/nested.rs new file mode 100644 index 0000000000..5e0a8b07c8 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/nested.rs @@ -0,0 +1,53 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Calc { + pub w: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Calc"][::std::mem::size_of::() - 4usize]; + ["Alignment of Calc"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Calc::w"][::std::mem::offset_of!(Calc, w) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Test { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Test_Size { + pub mWidth: Test_Size_Dimension, + pub mHeight: Test_Size_Dimension, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Test_Size_Dimension { + pub _base: Calc, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of Test_Size_Dimension", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of Test_Size_Dimension", + ][::std::mem::align_of::() - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Test_Size"][::std::mem::size_of::() - 8usize]; + ["Alignment of Test_Size"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: Test_Size::mWidth", + ][::std::mem::offset_of!(Test_Size, mWidth) - 0usize]; + [ + "Offset of field: Test_Size::mHeight", + ][::std::mem::offset_of!(Test_Size, mHeight) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Test"][::std::mem::size_of::() - 1usize]; + ["Alignment of Test"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/nested_vtable.rs b/bindgen-tests/tests/expectations/tests/nested_vtable.rs new file mode 100644 index 0000000000..12aa2ea441 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/nested_vtable.rs @@ -0,0 +1,70 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct nsISupports__bindgen_vtable { + pub nsISupports_QueryInterface: unsafe extern "C" fn( + this: *mut nsISupports, + ) -> *mut nsISupports, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nsISupports { + pub vtable_: *const nsISupports__bindgen_vtable, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of nsISupports"][::std::mem::size_of::() - 8usize]; + ["Alignment of nsISupports"][::std::mem::align_of::() - 8usize]; +}; +impl Default for nsISupports { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN11nsISupports14QueryInterfaceEv"] + pub fn nsISupports_QueryInterface( + this: *mut ::std::os::raw::c_void, + ) -> *mut nsISupports; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nsIRunnable { + pub _base: nsISupports, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of nsIRunnable"][::std::mem::size_of::() - 8usize]; + ["Alignment of nsIRunnable"][::std::mem::align_of::() - 8usize]; +}; +impl Default for nsIRunnable { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Runnable { + pub _base: nsIRunnable, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Runnable"][::std::mem::size_of::() - 8usize]; + ["Alignment of Runnable"][::std::mem::align_of::() - 8usize]; +}; +impl Default for Runnable { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/nested_within_namespace.rs b/bindgen-tests/tests/expectations/tests/nested_within_namespace.rs new file mode 100644 index 0000000000..f470571ddc --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/nested_within_namespace.rs @@ -0,0 +1,45 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod foo { + #[allow(unused_imports)] + use self::super::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Bar { + pub foo: ::std::os::raw::c_int, + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Bar_Baz { + pub foo: ::std::os::raw::c_int, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Bar_Baz"][::std::mem::size_of::() - 4usize]; + ["Alignment of Bar_Baz"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: Bar_Baz::foo", + ][::std::mem::offset_of!(Bar_Baz, foo) - 0usize]; + }; + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 4usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Bar::foo"][::std::mem::offset_of!(Bar, foo) - 0usize]; + }; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Baz { + pub baz: ::std::os::raw::c_int, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Baz"][::std::mem::size_of::() - 4usize]; + ["Alignment of Baz"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Baz::baz"][::std::mem::offset_of!(Baz, baz) - 0usize]; + }; + } +} diff --git a/bindgen-tests/tests/expectations/tests/new-type-alias.rs b/bindgen-tests/tests/expectations/tests/new-type-alias.rs new file mode 100644 index 0000000000..f63069cbe2 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/new-type-alias.rs @@ -0,0 +1,20 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const true_: u32 = 1; +#[repr(transparent)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo(pub u64); +pub const Foo_A: Foo = Foo(1); +#[repr(transparent)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Bar(pub ::std::os::raw::c_char); +pub const Bar_A: Bar = Bar(97); +#[repr(transparent)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Baz(pub f32); +pub const Baz_A: Baz = Baz(3.25); +#[repr(transparent)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Bang(pub bool); +pub const Bang_A: Bang = Bang(true); +pub type Boom = u64; +pub const Boom_A: Boom = 2; diff --git a/bindgen-tests/tests/expectations/tests/newtype-enum.rs b/bindgen-tests/tests/expectations/tests/newtype-enum.rs new file mode 100644 index 0000000000..0045c52a61 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/newtype-enum.rs @@ -0,0 +1,10 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +impl Foo { + pub const Bar: Foo = Foo(2); + pub const Baz: Foo = Foo(4); + pub const Duplicated: Foo = Foo(4); + pub const Negative: Foo = Foo(-3); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Foo(pub ::std::os::raw::c_int); diff --git a/bindgen-tests/tests/expectations/tests/newtype-global-enum.rs b/bindgen-tests/tests/expectations/tests/newtype-global-enum.rs new file mode 100644 index 0000000000..29b87bff06 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/newtype-global-enum.rs @@ -0,0 +1,8 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const Foo_Bar: Foo = Foo(2); +pub const Foo_Baz: Foo = Foo(4); +pub const Foo_Duplicated: Foo = Foo(4); +pub const Foo_Negative: Foo = Foo(-3); +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Foo(pub ::std::os::raw::c_int); diff --git a/bindgen-tests/tests/expectations/tests/no-comments.rs b/bindgen-tests/tests/expectations/tests/no-comments.rs new file mode 100644 index 0000000000..6a60973fb4 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no-comments.rs @@ -0,0 +1,12 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub s: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Foo::s"][::std::mem::offset_of!(Foo, s) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/no-derive-debug.rs b/bindgen-tests/tests/expectations/tests/no-derive-debug.rs new file mode 100644 index 0000000000..5e525068fd --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no-derive-debug.rs @@ -0,0 +1,30 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Default)] +pub struct foo { + bar: ::std::os::raw::c_int, +} +/** bar should compile. It will normally derive debug, but our blocklist of foo + and replacement for another type that doesn't implement it would prevent it + from building if --no-derive-debug didn't work.*/ +#[repr(C)] +pub struct bar { + pub foo: foo, + pub baz: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of bar"][::std::mem::size_of::() - 8usize]; + ["Alignment of bar"][::std::mem::align_of::() - 4usize]; + ["Offset of field: bar::foo"][::std::mem::offset_of!(bar, foo) - 0usize]; + ["Offset of field: bar::baz"][::std::mem::offset_of!(bar, baz) - 4usize]; +}; +impl Default for bar { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/no-derive-default.rs b/bindgen-tests/tests/expectations/tests/no-derive-default.rs new file mode 100644 index 0000000000..a1d86a6502 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no-derive-default.rs @@ -0,0 +1,21 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct foo { + bar: ::std::os::raw::c_int, +} +/** bar should compile. It will normally derive default, but our blocklist of foo + and replacement for another type that doesn't implement it would prevent it + from building if --no-derive-default didn't work.*/ +#[repr(C)] +pub struct bar { + pub foo: foo, + pub baz: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of bar"][::std::mem::size_of::() - 8usize]; + ["Alignment of bar"][::std::mem::align_of::() - 4usize]; + ["Offset of field: bar::foo"][::std::mem::offset_of!(bar, foo) - 0usize]; + ["Offset of field: bar::baz"][::std::mem::offset_of!(bar, baz) - 4usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/no-hash-allowlisted.rs b/bindgen-tests/tests/expectations/tests/no-hash-allowlisted.rs new file mode 100644 index 0000000000..ff4dd1e38e --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no-hash-allowlisted.rs @@ -0,0 +1,12 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct NoHash { + pub i: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of NoHash"][::std::mem::size_of::() - 4usize]; + ["Alignment of NoHash"][::std::mem::align_of::() - 4usize]; + ["Offset of field: NoHash::i"][::std::mem::offset_of!(NoHash, i) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/no-hash-opaque.rs b/bindgen-tests/tests/expectations/tests/no-hash-opaque.rs new file mode 100644 index 0000000000..9dc9e01989 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no-hash-opaque.rs @@ -0,0 +1,12 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Default, Copy, Clone)] +pub struct NoHash { + pub _bindgen_opaque_blob: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of NoHash"][::std::mem::size_of::() - 4usize]; + ["Alignment of NoHash"][::std::mem::align_of::() - 4usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/no-partialeq-allowlisted.rs b/bindgen-tests/tests/expectations/tests/no-partialeq-allowlisted.rs new file mode 100644 index 0000000000..68ae1a7449 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no-partialeq-allowlisted.rs @@ -0,0 +1,12 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct NoPartialEq { + pub i: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of NoPartialEq"][::std::mem::size_of::() - 4usize]; + ["Alignment of NoPartialEq"][::std::mem::align_of::() - 4usize]; + ["Offset of field: NoPartialEq::i"][::std::mem::offset_of!(NoPartialEq, i) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/no-partialeq-opaque.rs b/bindgen-tests/tests/expectations/tests/no-partialeq-opaque.rs new file mode 100644 index 0000000000..4b488df6a5 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no-partialeq-opaque.rs @@ -0,0 +1,12 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Default, Copy, Clone)] +pub struct NoPartialEq { + pub _bindgen_opaque_blob: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of NoPartialEq"][::std::mem::size_of::() - 4usize]; + ["Alignment of NoPartialEq"][::std::mem::align_of::() - 4usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/no-recursive-allowlisting.rs b/bindgen-tests/tests/expectations/tests/no-recursive-allowlisting.rs new file mode 100644 index 0000000000..dc1e4721ab --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no-recursive-allowlisting.rs @@ -0,0 +1,22 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub enum Bar {} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Foo { + pub baz: *mut Bar, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 8usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Foo::baz"][::std::mem::offset_of!(Foo, baz) - 0usize]; +}; +impl Default for Foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/no-std.rs b/bindgen-tests/tests/expectations/tests/no-std.rs new file mode 100644 index 0000000000..0f03c222ef --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no-std.rs @@ -0,0 +1,30 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![no_std] +mod libc { + pub type c_int = i32; + pub enum c_void {} +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct foo { + pub a: libc::c_int, + pub b: libc::c_int, + pub bar: *mut libc::c_void, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::core::mem::size_of::() - 16usize]; + ["Alignment of foo"][::core::mem::align_of::() - 8usize]; + ["Offset of field: foo::a"][::core::mem::offset_of!(foo, a) - 0usize]; + ["Offset of field: foo::b"][::core::mem::offset_of!(foo, b) - 4usize]; + ["Offset of field: foo::bar"][::core::mem::offset_of!(foo, bar) - 8usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/no_copy.rs b/bindgen-tests/tests/expectations/tests/no_copy.rs new file mode 100644 index 0000000000..b92c542482 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no_copy.rs @@ -0,0 +1,7 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +///
+#[repr(C)] +#[derive(Debug, Default)] +pub struct CopiableButWait { + pub whatever: ::std::os::raw::c_int, +} diff --git a/bindgen-tests/tests/expectations/tests/no_copy_allowlisted.rs b/bindgen-tests/tests/expectations/tests/no_copy_allowlisted.rs new file mode 100644 index 0000000000..67be391799 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no_copy_allowlisted.rs @@ -0,0 +1,12 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default)] +pub struct NoCopy { + pub i: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of NoCopy"][::std::mem::size_of::() - 4usize]; + ["Alignment of NoCopy"][::std::mem::align_of::() - 4usize]; + ["Offset of field: NoCopy::i"][::std::mem::offset_of!(NoCopy, i) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/no_copy_opaque.rs b/bindgen-tests/tests/expectations/tests/no_copy_opaque.rs new file mode 100644 index 0000000000..dea6a0a6cf --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no_copy_opaque.rs @@ -0,0 +1,12 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Default)] +pub struct NoCopy { + pub _bindgen_opaque_blob: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of NoCopy"][::std::mem::size_of::() - 4usize]; + ["Alignment of NoCopy"][::std::mem::align_of::() - 4usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/no_debug.rs b/bindgen-tests/tests/expectations/tests/no_debug.rs new file mode 100644 index 0000000000..9a162c6f70 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no_debug.rs @@ -0,0 +1,7 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +///
+#[repr(C)] +#[derive(Default, Copy, Clone)] +pub struct DebugButWait { + pub whatever: ::std::os::raw::c_int, +} diff --git a/bindgen-tests/tests/expectations/tests/no_debug_allowlisted.rs b/bindgen-tests/tests/expectations/tests/no_debug_allowlisted.rs new file mode 100644 index 0000000000..1ddb20a747 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no_debug_allowlisted.rs @@ -0,0 +1,12 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Default, Copy, Clone)] +pub struct NoDebug { + pub i: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of NoDebug"][::std::mem::size_of::() - 4usize]; + ["Alignment of NoDebug"][::std::mem::align_of::() - 4usize]; + ["Offset of field: NoDebug::i"][::std::mem::offset_of!(NoDebug, i) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/no_debug_bypass_impl_debug.rs b/bindgen-tests/tests/expectations/tests/no_debug_bypass_impl_debug.rs new file mode 100644 index 0000000000..ceec3823ae --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no_debug_bypass_impl_debug.rs @@ -0,0 +1,30 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug)] +pub struct Generic { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub t: [T; 40usize], +} +impl Default for Generic { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +pub struct NoDebug { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub t: [T; 40usize], +} +impl Default for NoDebug { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/no_debug_opaque.rs b/bindgen-tests/tests/expectations/tests/no_debug_opaque.rs new file mode 100644 index 0000000000..0bb37ec711 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no_debug_opaque.rs @@ -0,0 +1,12 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[repr(align(4))] +#[derive(Default, Copy, Clone)] +pub struct NoDebug { + pub _bindgen_opaque_blob: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of NoDebug"][::std::mem::size_of::() - 4usize]; + ["Alignment of NoDebug"][::std::mem::align_of::() - 4usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/no_default.rs b/bindgen-tests/tests/expectations/tests/no_default.rs new file mode 100644 index 0000000000..fd3d86e277 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no_default.rs @@ -0,0 +1,21 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +///
+#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct DefaultButWait { + pub whatever: ::std::os::raw::c_int, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct DefaultButWaitDerived { + pub whatever: DefaultButWait, +} +impl Default for DefaultButWaitDerived { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/no_default_allowlisted.rs b/bindgen-tests/tests/expectations/tests/no_default_allowlisted.rs new file mode 100644 index 0000000000..593e644343 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no_default_allowlisted.rs @@ -0,0 +1,12 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NoDefault { + pub i: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of NoDefault"][::std::mem::size_of::() - 4usize]; + ["Alignment of NoDefault"][::std::mem::align_of::() - 4usize]; + ["Offset of field: NoDefault::i"][::std::mem::offset_of!(NoDefault, i) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/no_default_bypass_derive_default.rs b/bindgen-tests/tests/expectations/tests/no_default_bypass_derive_default.rs new file mode 100644 index 0000000000..3dfd34474a --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no_default_bypass_derive_default.rs @@ -0,0 +1,22 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug)] +pub struct Generic { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub t: [T; 40usize], +} +impl Default for Generic { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug)] +pub struct NoDefault { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub t: [T; 40usize], +} diff --git a/bindgen-tests/tests/expectations/tests/no_default_opaque.rs b/bindgen-tests/tests/expectations/tests/no_default_opaque.rs new file mode 100644 index 0000000000..ba2f63f91c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no_default_opaque.rs @@ -0,0 +1,12 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct NoDefault { + pub _bindgen_opaque_blob: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of NoDefault"][::std::mem::size_of::() - 4usize]; + ["Alignment of NoDefault"][::std::mem::align_of::() - 4usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/no_size_t_is_usize.rs b/bindgen-tests/tests/expectations/tests/no_size_t_is_usize.rs new file mode 100644 index 0000000000..94ce735b31 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/no_size_t_is_usize.rs @@ -0,0 +1,27 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type size_t = ::std::os::raw::c_ulong; +pub type ssize_t = ::std::os::raw::c_long; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct A { + pub len: size_t, + pub offset: ssize_t, + pub next: *mut A, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A"][::std::mem::size_of::() - 24usize]; + ["Alignment of A"][::std::mem::align_of::() - 8usize]; + ["Offset of field: A::len"][::std::mem::offset_of!(A, len) - 0usize]; + ["Offset of field: A::offset"][::std::mem::offset_of!(A, offset) - 8usize]; + ["Offset of field: A::next"][::std::mem::offset_of!(A, next) - 16usize]; +}; +impl Default for A { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/non-type-params.rs b/bindgen-tests/tests/expectations/tests/non-type-params.rs new file mode 100644 index 0000000000..325620b9bb --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/non-type-params.rs @@ -0,0 +1,32 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)] +#[repr(C)] +pub struct __BindgenOpaqueArray(pub T); +impl Default for __BindgenOpaqueArray<[T; N]> { + fn default() -> Self { + Self([::default(); N]) + } +} +pub type Array16 = u8; +pub type ArrayInt4 = __BindgenOpaqueArray<[u32; 4usize]>; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct UsesArray { + pub array_char_16: __BindgenOpaqueArray<[u8; 16usize]>, + pub array_bool_8: __BindgenOpaqueArray<[u8; 8usize]>, + pub array_int_4: ArrayInt4, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of UsesArray"][::std::mem::size_of::() - 40usize]; + ["Alignment of UsesArray"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: UsesArray::array_char_16", + ][::std::mem::offset_of!(UsesArray, array_char_16) - 0usize]; + [ + "Offset of field: UsesArray::array_bool_8", + ][::std::mem::offset_of!(UsesArray, array_bool_8) - 16usize]; + [ + "Offset of field: UsesArray::array_int_4", + ][::std::mem::offset_of!(UsesArray, array_int_4) - 24usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/noreturn.rs b/bindgen-tests/tests/expectations/tests/noreturn.rs new file mode 100644 index 0000000000..0e601b5510 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/noreturn.rs @@ -0,0 +1,21 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + #[link_name = "\u{1}_Z1fv"] + pub fn f() -> !; +} +unsafe extern "C" { + #[link_name = "\u{1}_Z1gv"] + pub fn g() -> !; +} +unsafe extern "C" { + #[link_name = "\u{1}_Z1hv"] + pub fn h() -> !; +} +unsafe extern "C" { + #[link_name = "\u{1}_Z1iPFvvE"] + pub fn i(arg: ::std::option::Option !>); +} +unsafe extern "C" { + #[link_name = "\u{1}_Z1jPFvvE"] + pub fn j(arg: ::std::option::Option !>) -> !; +} diff --git a/bindgen-tests/tests/expectations/tests/nsBaseHashtable.rs b/bindgen-tests/tests/expectations/tests/nsBaseHashtable.rs new file mode 100644 index 0000000000..81b9f000c6 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/nsBaseHashtable.rs @@ -0,0 +1,65 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)] +#[repr(C)] +pub struct __BindgenOpaqueArray(pub T); +impl Default for __BindgenOpaqueArray<[T; N]> { + fn default() -> Self { + Self([::default(); N]) + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct nsBaseHashtableET { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct nsTHashtable { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nsBaseHashtable { + pub _address: u8, +} +pub type nsBaseHashtable_KeyType = __BindgenOpaqueArray<[u8; 0usize]>; +pub type nsBaseHashtable_EntryType = nsBaseHashtableET; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nsBaseHashtable_LookupResult { + pub mEntry: *mut nsBaseHashtable_EntryType, + pub mTable: *mut nsBaseHashtable, +} +impl Default for nsBaseHashtable_LookupResult { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug)] +pub struct nsBaseHashtable_EntryPtr { + pub mEntry: *mut nsBaseHashtable_EntryType, + pub mExistingEntry: bool, +} +impl Default for nsBaseHashtable_EntryPtr { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Default for nsBaseHashtable { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/nsStyleAutoArray.rs b/bindgen-tests/tests/expectations/tests/nsStyleAutoArray.rs new file mode 100644 index 0000000000..3d8edcfdc1 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/nsStyleAutoArray.rs @@ -0,0 +1,37 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nsTArray { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub mBuff: *mut T, +} +impl Default for nsTArray { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nsStyleAutoArray { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub mFirstElement: T, + pub mOtherElements: nsTArray, +} +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum nsStyleAutoArray_WithSingleInitialElement { + WITH_SINGLE_INITIAL_ELEMENT = 0, +} +impl Default for nsStyleAutoArray { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/objc_allowlist.rs b/bindgen-tests/tests/expectations/tests/objc_allowlist.rs new file mode 100644 index 0000000000..7ccd4e3c04 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/objc_allowlist.rs @@ -0,0 +1,52 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +use objc::{self, msg_send, sel, sel_impl, class}; +#[allow(non_camel_case_types)] +pub type id = *mut objc::runtime::Object; +pub trait PSomeProtocol: Sized + std::ops::Deref { + unsafe fn protocolMethod(&self) + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, protocolMethod) + } + unsafe fn protocolClassMethod() + where + ::Target: objc::Message + Sized, + { + msg_send!(class!(SomeProtocol), protocolClassMethod) + } +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct AllowlistMe(pub id); +impl std::ops::Deref for AllowlistMe { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for AllowlistMe {} +impl AllowlistMe { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(AllowlistMe), alloc) }) + } +} +impl PSomeProtocol for AllowlistMe {} +impl IAllowlistMe for AllowlistMe {} +pub trait IAllowlistMe: Sized + std::ops::Deref { + unsafe fn method(&self) + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, method) + } + unsafe fn classMethod() + where + ::Target: objc::Message + Sized, + { + msg_send!(class!(AllowlistMe), classMethod) + } +} +impl AllowlistMe_InterestingCategory for AllowlistMe {} +pub trait AllowlistMe_InterestingCategory: Sized + std::ops::Deref {} diff --git a/bindgen-tests/tests/expectations/tests/objc_blocklist.rs b/bindgen-tests/tests/expectations/tests/objc_blocklist.rs new file mode 100644 index 0000000000..e5c5d2bfd5 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/objc_blocklist.rs @@ -0,0 +1,36 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +#[macro_use] +extern crate objc; +#[allow(non_camel_case_types)] +pub type id = *mut objc::runtime::Object; +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct SomeClass(pub id); +impl std::ops::Deref for SomeClass { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for SomeClass {} +impl SomeClass { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(SomeClass), alloc) }) + } +} +impl ISomeClass for SomeClass {} +pub trait ISomeClass: Sized + std::ops::Deref { + unsafe fn ambiguouslyBlockedMethod(&self) + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, ambiguouslyBlockedMethod) + } + unsafe fn instanceMethod(&self) + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, instanceMethod) + } +} diff --git a/bindgen-tests/tests/expectations/tests/objc_category.rs b/bindgen-tests/tests/expectations/tests/objc_category.rs new file mode 100644 index 0000000000..a1b1e3b1f1 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/objc_category.rs @@ -0,0 +1,38 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +use objc::{self, msg_send, sel, sel_impl, class}; +#[allow(non_camel_case_types)] +pub type id = *mut objc::runtime::Object; +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct Foo(pub id); +impl std::ops::Deref for Foo { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for Foo {} +impl Foo { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(Foo), alloc) }) + } +} +impl IFoo for Foo {} +pub trait IFoo: Sized + std::ops::Deref { + unsafe fn method(&self) + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, method) + } +} +impl Foo_BarCategory for Foo {} +pub trait Foo_BarCategory: Sized + std::ops::Deref { + unsafe fn categoryMethod(&self) + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, categoryMethod) + } +} diff --git a/bindgen-tests/tests/expectations/tests/objc_class.rs b/bindgen-tests/tests/expectations/tests/objc_class.rs new file mode 100644 index 0000000000..a7346d1ee9 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/objc_class.rs @@ -0,0 +1,32 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +use objc::{self, msg_send, sel, sel_impl, class}; +#[allow(non_camel_case_types)] +pub type id = *mut objc::runtime::Object; +unsafe extern "C" { + pub static mut fooVar: Foo; +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct Foo(pub id); +impl std::ops::Deref for Foo { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for Foo {} +impl Foo { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(Foo), alloc) }) + } +} +impl IFoo for Foo {} +pub trait IFoo: Sized + std::ops::Deref { + unsafe fn method(&self) + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, method) + } +} diff --git a/bindgen-tests/tests/expectations/tests/objc_class_method.rs b/bindgen-tests/tests/expectations/tests/objc_class_method.rs new file mode 100644 index 0000000000..6bc2621462 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/objc_class_method.rs @@ -0,0 +1,65 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +use objc::{self, msg_send, sel, sel_impl, class}; +#[allow(non_camel_case_types)] +pub type id = *mut objc::runtime::Object; +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct Foo(pub id); +impl std::ops::Deref for Foo { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for Foo {} +impl Foo { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(Foo), alloc) }) + } +} +impl IFoo for Foo {} +pub trait IFoo: Sized + std::ops::Deref { + unsafe fn method() + where + ::Target: objc::Message + Sized, + { + msg_send!(class!(Foo), method) + } + unsafe fn methodWithInt_(foo: ::std::os::raw::c_int) + where + ::Target: objc::Message + Sized, + { + msg_send!(class!(Foo), methodWithInt : foo) + } + unsafe fn methodWithFoo_(foo: Foo) + where + ::Target: objc::Message + Sized, + { + msg_send!(class!(Foo), methodWithFoo : foo) + } + unsafe fn methodReturningInt() -> ::std::os::raw::c_int + where + ::Target: objc::Message + Sized, + { + msg_send!(class!(Foo), methodReturningInt) + } + unsafe fn methodReturningFoo() -> Foo + where + ::Target: objc::Message + Sized, + { + msg_send!(class!(Foo), methodReturningFoo) + } + unsafe fn methodWithArg1_andArg2_andArg3_( + intvalue: ::std::os::raw::c_int, + ptr: *mut ::std::os::raw::c_char, + floatvalue: f32, + ) + where + ::Target: objc::Message + Sized, + { + msg_send!( + class!(Foo), methodWithArg1 : intvalue andArg2 : ptr andArg3 : floatvalue + ) + } +} diff --git a/bindgen-tests/tests/expectations/tests/objc_escape.rs b/bindgen-tests/tests/expectations/tests/objc_escape.rs new file mode 100644 index 0000000000..1351231d62 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/objc_escape.rs @@ -0,0 +1,65 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +use objc::{self, msg_send, sel, sel_impl, class}; +#[allow(non_camel_case_types)] +pub type id = *mut objc::runtime::Object; +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct A(pub id); +impl std::ops::Deref for A { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for A {} +impl A { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(A), alloc) }) + } +} +impl IA for A {} +pub trait IA: Sized + std::ops::Deref { + unsafe fn f_as_(&self, arg1: ::std::os::raw::c_int, arg2: ::std::os::raw::c_int) + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, f : arg1 r#as : arg2) + } + unsafe fn crate_(&self, self_: ::std::os::raw::c_int) + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, crate_ : self_) + } +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct B(pub id); +impl std::ops::Deref for B { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for B {} +impl B { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(B), alloc) }) + } +} +impl IB for B {} +pub trait IB: Sized + std::ops::Deref { + unsafe fn type_(&self) -> id + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, type) + } + unsafe fn setType_(&self, type_: id) + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, setType : type_) + } +} diff --git a/bindgen-tests/tests/expectations/tests/objc_inheritance.rs b/bindgen-tests/tests/expectations/tests/objc_inheritance.rs new file mode 100644 index 0000000000..6fb4e6b857 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/objc_inheritance.rs @@ -0,0 +1,107 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +use objc::{self, msg_send, sel, sel_impl, class}; +#[allow(non_camel_case_types)] +pub type id = *mut objc::runtime::Object; +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct Foo(pub id); +impl std::ops::Deref for Foo { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for Foo {} +impl Foo { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(Foo), alloc) }) + } +} +impl IFoo for Foo {} +pub trait IFoo: Sized + std::ops::Deref {} +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct Bar(pub id); +impl std::ops::Deref for Bar { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for Bar {} +impl Bar { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(Bar), alloc) }) + } +} +impl IFoo for Bar {} +impl From for Foo { + fn from(child: Bar) -> Foo { + Foo(child.0) + } +} +impl std::convert::TryFrom for Bar { + type Error = &'static str; + fn try_from(parent: Foo) -> Result { + let is_kind_of: bool = unsafe { msg_send!(parent, isKindOfClass : class!(Bar)) }; + if is_kind_of { + Ok(Bar(parent.0)) + } else { + Err("This Foo cannot be downcasted to Bar") + } + } +} +impl IBar for Bar {} +pub trait IBar: Sized + std::ops::Deref {} +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct Baz(pub id); +impl std::ops::Deref for Baz { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for Baz {} +impl Baz { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(Baz), alloc) }) + } +} +impl IBar for Baz {} +impl From for Bar { + fn from(child: Baz) -> Bar { + Bar(child.0) + } +} +impl std::convert::TryFrom for Baz { + type Error = &'static str; + fn try_from(parent: Bar) -> Result { + let is_kind_of: bool = unsafe { msg_send!(parent, isKindOfClass : class!(Baz)) }; + if is_kind_of { + Ok(Baz(parent.0)) + } else { + Err("This Bar cannot be downcasted to Baz") + } + } +} +impl IFoo for Baz {} +impl From for Foo { + fn from(child: Baz) -> Foo { + Foo(child.0) + } +} +impl std::convert::TryFrom for Baz { + type Error = &'static str; + fn try_from(parent: Foo) -> Result { + let is_kind_of: bool = unsafe { msg_send!(parent, isKindOfClass : class!(Baz)) }; + if is_kind_of { + Ok(Baz(parent.0)) + } else { + Err("This Foo cannot be downcasted to Baz") + } + } +} +impl IBaz for Baz {} +pub trait IBaz: Sized + std::ops::Deref {} diff --git a/bindgen-tests/tests/expectations/tests/objc_interface.rs b/bindgen-tests/tests/expectations/tests/objc_interface.rs new file mode 100644 index 0000000000..2cc602efd4 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/objc_interface.rs @@ -0,0 +1,23 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +use objc::{self, msg_send, sel, sel_impl, class}; +#[allow(non_camel_case_types)] +pub type id = *mut objc::runtime::Object; +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct Foo(pub id); +impl std::ops::Deref for Foo { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for Foo {} +impl Foo { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(Foo), alloc) }) + } +} +impl IFoo for Foo {} +pub trait IFoo: Sized + std::ops::Deref {} +pub trait Pbar: Sized + std::ops::Deref {} diff --git a/bindgen-tests/tests/expectations/tests/objc_interface_type.rs b/bindgen-tests/tests/expectations/tests/objc_interface_type.rs new file mode 100644 index 0000000000..56ad75ed25 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/objc_interface_type.rs @@ -0,0 +1,48 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +use objc::{self, msg_send, sel, sel_impl, class}; +#[allow(non_camel_case_types)] +pub type id = *mut objc::runtime::Object; +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct Foo(pub id); +impl std::ops::Deref for Foo { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for Foo {} +impl Foo { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(Foo), alloc) }) + } +} +impl IFoo for Foo {} +pub trait IFoo: Sized + std::ops::Deref {} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FooStruct { + pub foo: Foo, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of FooStruct"][::std::mem::size_of::() - 8usize]; + ["Alignment of FooStruct"][::std::mem::align_of::() - 8usize]; + ["Offset of field: FooStruct::foo"][::std::mem::offset_of!(FooStruct, foo) - 0usize]; +}; +impl Default for FooStruct { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +unsafe extern "C" { + pub fn fooFunc(foo: Foo); +} +unsafe extern "C" { + pub static mut kFoo: Foo; +} diff --git a/bindgen-tests/tests/expectations/tests/objc_method.rs b/bindgen-tests/tests/expectations/tests/objc_method.rs new file mode 100644 index 0000000000..7d9fd84cf2 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/objc_method.rs @@ -0,0 +1,80 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +use objc::{self, msg_send, sel, sel_impl, class}; +#[allow(non_camel_case_types)] +pub type id = *mut objc::runtime::Object; +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct Foo(pub id); +impl std::ops::Deref for Foo { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for Foo {} +impl Foo { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(Foo), alloc) }) + } +} +impl IFoo for Foo {} +pub trait IFoo: Sized + std::ops::Deref { + unsafe fn method(&self) + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, method) + } + unsafe fn methodWithInt_(&self, foo: ::std::os::raw::c_int) + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, methodWithInt : foo) + } + unsafe fn methodWithFoo_(&self, foo: Foo) + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, methodWithFoo : foo) + } + unsafe fn methodReturningInt(&self) -> ::std::os::raw::c_int + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, methodReturningInt) + } + unsafe fn methodReturningFoo(&self) -> Foo + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, methodReturningFoo) + } + unsafe fn methodWithArg1_andArg2_andArg3_( + &self, + intvalue: ::std::os::raw::c_int, + ptr: *mut ::std::os::raw::c_char, + floatvalue: f32, + ) + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, methodWithArg1 : intvalue andArg2 : ptr andArg3 : floatvalue) + } + unsafe fn methodWithAndWithoutKeywords_arg2Name__arg4Name_( + &self, + arg1: ::std::os::raw::c_int, + arg2: f32, + arg3: f32, + arg4: ::std::os::raw::c_int, + ) -> instancetype + where + ::Target: objc::Message + Sized, + { + msg_send!( + * self, methodWithAndWithoutKeywords : arg1 arg2Name : arg2 arg3 : arg3 + arg4Name : arg4 + ) + } +} +pub type instancetype = id; diff --git a/bindgen-tests/tests/expectations/tests/objc_method_clash.rs b/bindgen-tests/tests/expectations/tests/objc_method_clash.rs new file mode 100644 index 0000000000..4d35661f8c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/objc_method_clash.rs @@ -0,0 +1,35 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +use objc::{self, msg_send, sel, sel_impl, class}; +#[allow(non_camel_case_types)] +pub type id = *mut objc::runtime::Object; +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct Foo(pub id); +impl std::ops::Deref for Foo { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for Foo {} +impl Foo { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(Foo), alloc) }) + } +} +impl IFoo for Foo {} +pub trait IFoo: Sized + std::ops::Deref { + unsafe fn foo(&self) + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, foo) + } + unsafe fn class_foo() + where + ::Target: objc::Message + Sized, + { + msg_send!(class!(Foo), foo) + } +} diff --git a/bindgen-tests/tests/expectations/tests/objc_pointer_return_types.rs b/bindgen-tests/tests/expectations/tests/objc_pointer_return_types.rs new file mode 100644 index 0000000000..73c3d6e5c8 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/objc_pointer_return_types.rs @@ -0,0 +1,52 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +use objc::{self, msg_send, sel, sel_impl, class}; +#[allow(non_camel_case_types)] +pub type id = *mut objc::runtime::Object; +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct Bar(pub id); +impl std::ops::Deref for Bar { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for Bar {} +impl Bar { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(Bar), alloc) }) + } +} +impl IBar for Bar {} +pub trait IBar: Sized + std::ops::Deref {} +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct Foo(pub id); +impl std::ops::Deref for Foo { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for Foo {} +impl Foo { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(Foo), alloc) }) + } +} +impl IFoo for Foo {} +pub trait IFoo: Sized + std::ops::Deref { + unsafe fn methodUsingBar_(&self, my_bar: Bar) + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, methodUsingBar : my_bar) + } + unsafe fn methodReturningBar() -> Bar + where + ::Target: objc::Message + Sized, + { + msg_send!(class!(Foo), methodReturningBar) + } +} diff --git a/bindgen-tests/tests/expectations/tests/objc_property_fnptr.rs b/bindgen-tests/tests/expectations/tests/objc_property_fnptr.rs new file mode 100644 index 0000000000..e038edf7f1 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/objc_property_fnptr.rs @@ -0,0 +1,52 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +use objc::{self, msg_send, sel, sel_impl, class}; +#[allow(non_camel_case_types)] +pub type id = *mut objc::runtime::Object; +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct Foo(pub id); +impl std::ops::Deref for Foo { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for Foo {} +impl Foo { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(Foo), alloc) }) + } +} +impl IFoo for Foo {} +pub trait IFoo: Sized + std::ops::Deref { + unsafe fn func( + &self, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_char, + arg2: ::std::os::raw::c_short, + arg3: f32, + ) -> ::std::os::raw::c_int, + > + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, func) + } + unsafe fn setFunc_( + &self, + func: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_char, + arg2: ::std::os::raw::c_short, + arg3: f32, + ) -> ::std::os::raw::c_int, + >, + ) + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, setFunc : func) + } +} diff --git a/bindgen-tests/tests/expectations/tests/objc_protocol.rs b/bindgen-tests/tests/expectations/tests/objc_protocol.rs new file mode 100644 index 0000000000..533f5e2ef3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/objc_protocol.rs @@ -0,0 +1,24 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +use objc::{self, msg_send, sel, sel_impl, class}; +#[allow(non_camel_case_types)] +pub type id = *mut objc::runtime::Object; +pub trait PFoo: Sized + std::ops::Deref {} +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct Foo(pub id); +impl std::ops::Deref for Foo { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for Foo {} +impl Foo { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(Foo), alloc) }) + } +} +impl PFoo for Foo {} +impl IFoo for Foo {} +pub trait IFoo: Sized + std::ops::Deref {} diff --git a/bindgen-tests/tests/expectations/tests/objc_protocol_inheritance.rs b/bindgen-tests/tests/expectations/tests/objc_protocol_inheritance.rs new file mode 100644 index 0000000000..8bb0ef6f62 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/objc_protocol_inheritance.rs @@ -0,0 +1,59 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +use objc::{self, msg_send, sel, sel_impl, class}; +#[allow(non_camel_case_types)] +pub type id = *mut objc::runtime::Object; +pub trait PFoo: Sized + std::ops::Deref {} +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct Foo(pub id); +impl std::ops::Deref for Foo { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for Foo {} +impl Foo { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(Foo), alloc) }) + } +} +impl PFoo for Foo {} +impl IFoo for Foo {} +pub trait IFoo: Sized + std::ops::Deref {} +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct Bar(pub id); +impl std::ops::Deref for Bar { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for Bar {} +impl Bar { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(Bar), alloc) }) + } +} +impl IFoo for Bar {} +impl PFoo for Bar {} +impl From for Foo { + fn from(child: Bar) -> Foo { + Foo(child.0) + } +} +impl std::convert::TryFrom for Bar { + type Error = &'static str; + fn try_from(parent: Foo) -> Result { + let is_kind_of: bool = unsafe { msg_send!(parent, isKindOfClass : class!(Bar)) }; + if is_kind_of { + Ok(Bar(parent.0)) + } else { + Err("This Foo cannot be downcasted to Bar") + } + } +} +impl IBar for Bar {} +pub trait IBar: Sized + std::ops::Deref {} diff --git a/bindgen-tests/tests/expectations/tests/objc_sel_and_id.rs b/bindgen-tests/tests/expectations/tests/objc_sel_and_id.rs new file mode 100644 index 0000000000..cf38af4e64 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/objc_sel_and_id.rs @@ -0,0 +1,14 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +use objc::{self, msg_send, sel, sel_impl, class}; +#[allow(non_camel_case_types)] +pub type id = *mut objc::runtime::Object; +unsafe extern "C" { + pub static mut object: id; +} +unsafe extern "C" { + pub static mut selector: objc::runtime::Sel; +} +unsafe extern "C" { + pub fn f(object: id, selector: objc::runtime::Sel); +} diff --git a/bindgen-tests/tests/expectations/tests/objc_template.rs b/bindgen-tests/tests/expectations/tests/objc_template.rs new file mode 100644 index 0000000000..1c70009df3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/objc_template.rs @@ -0,0 +1,68 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +use objc::{self, msg_send, sel, sel_impl, class}; +#[allow(non_camel_case_types)] +pub type id = *mut objc::runtime::Object; +#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)] +#[repr(C, align(8))] +pub struct __BindgenOpaqueArray8(pub T); +impl Default for __BindgenOpaqueArray8<[T; N]> { + fn default() -> Self { + Self([::default(); N]) + } +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct Foo(pub id); +impl std::ops::Deref for Foo { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for Foo {} +impl Foo { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(Foo), alloc) }) + } +} +impl IFoo for Foo {} +pub trait IFoo: Sized + std::ops::Deref { + unsafe fn get(&self) -> __BindgenOpaqueArray8<[u8; 8usize]> + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, get) + } +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct FooMultiGeneric(pub id); +impl std::ops::Deref for FooMultiGeneric { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for FooMultiGeneric {} +impl FooMultiGeneric { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(FooMultiGeneric), alloc) }) + } +} +impl IFooMultiGeneric +for FooMultiGeneric {} +pub trait IFooMultiGeneric< + KeyType: 'static, + ObjectType: 'static, +>: Sized + std::ops::Deref { + unsafe fn objectForKey_( + &self, + key: __BindgenOpaqueArray8<[u8; 8usize]>, + ) -> __BindgenOpaqueArray8<[u8; 8usize]> + where + ::Target: objc::Message + Sized, + { + msg_send!(* self, objectForKey : key) + } +} diff --git a/bindgen-tests/tests/expectations/tests/only_bitfields.rs b/bindgen-tests/tests/expectations/tests/only_bitfields.rs new file mode 100644 index 0000000000..9a73fc2fee --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/only_bitfields.rs @@ -0,0 +1,252 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct C { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C"][::std::mem::size_of::() - 1usize]; + ["Alignment of C"][::std::mem::align_of::() - 1usize]; +}; +impl C { + #[inline] + pub fn a(&self) -> bool { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_a(&mut self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn a_raw(this: *const Self) -> bool { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_a_raw(this: *mut Self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn b(&self) -> bool { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8) } + } + #[inline] + pub fn set_b(&mut self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 7u8, val as u64) + } + } + #[inline] + pub unsafe fn b_raw(this: *const Self) -> bool { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 7u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_b_raw(this: *mut Self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 7u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(a: bool, b: bool) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let a: u8 = unsafe { ::std::mem::transmute(a) }; + a as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 7u8, + { + let b: u8 = unsafe { ::std::mem::transmute(b) }; + b as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/opaque-template-inst-member-2.rs b/bindgen-tests/tests/expectations/tests/opaque-template-inst-member-2.rs new file mode 100644 index 0000000000..14718a9312 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/opaque-template-inst-member-2.rs @@ -0,0 +1,58 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +/** This is like `opaque-template-inst-member.hpp` except exercising the cases + where we are OK to derive Debug/Hash/PartialEq.*/ +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct OpaqueTemplate { + pub _address: u8, +} +/// Should derive Debug/Hash/PartialEq. +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct ContainsOpaqueTemplate { + pub mBlah: u32, + pub mBaz: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of ContainsOpaqueTemplate", + ][::std::mem::size_of::() - 8usize]; + [ + "Alignment of ContainsOpaqueTemplate", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: ContainsOpaqueTemplate::mBlah", + ][::std::mem::offset_of!(ContainsOpaqueTemplate, mBlah) - 0usize]; + [ + "Offset of field: ContainsOpaqueTemplate::mBaz", + ][::std::mem::offset_of!(ContainsOpaqueTemplate, mBaz) - 4usize]; +}; +/// Should also derive Debug/Hash/PartialEq. +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct InheritsOpaqueTemplate { + pub _base: u8, + pub wow: *mut ::std::os::raw::c_char, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of InheritsOpaqueTemplate", + ][::std::mem::size_of::() - 16usize]; + [ + "Alignment of InheritsOpaqueTemplate", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: InheritsOpaqueTemplate::wow", + ][::std::mem::offset_of!(InheritsOpaqueTemplate, wow) - 8usize]; +}; +impl Default for InheritsOpaqueTemplate { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/opaque-template-inst-member.rs b/bindgen-tests/tests/expectations/tests/opaque-template-inst-member.rs new file mode 100644 index 0000000000..f765f01150 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/opaque-template-inst-member.rs @@ -0,0 +1,66 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)] +#[repr(C)] +pub struct __BindgenOpaqueArray(pub T); +impl Default for __BindgenOpaqueArray<[T; N]> { + fn default() -> Self { + Self([::default(); N]) + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct OpaqueTemplate { + pub _address: u8, +} +/** This should not end up deriving Debug/Hash because its `mBlah` field cannot derive + Debug/Hash because the instantiation's definition cannot derive Debug/Hash.*/ +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct ContainsOpaqueTemplate { + pub mBlah: __BindgenOpaqueArray<[u32; 101usize]>, + pub mBaz: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of ContainsOpaqueTemplate", + ][::std::mem::size_of::() - 408usize]; + [ + "Alignment of ContainsOpaqueTemplate", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: ContainsOpaqueTemplate::mBlah", + ][::std::mem::offset_of!(ContainsOpaqueTemplate, mBlah) - 0usize]; + [ + "Offset of field: ContainsOpaqueTemplate::mBaz", + ][::std::mem::offset_of!(ContainsOpaqueTemplate, mBaz) - 404usize]; +}; +/** This should not end up deriving Debug/Hash either, for similar reasons, although + we're exercising base member edges now.*/ +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct InheritsOpaqueTemplate { + pub _base: __BindgenOpaqueArray<[u8; 401usize]>, + pub wow: *mut ::std::os::raw::c_char, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of InheritsOpaqueTemplate", + ][::std::mem::size_of::() - 416usize]; + [ + "Alignment of InheritsOpaqueTemplate", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: InheritsOpaqueTemplate::wow", + ][::std::mem::offset_of!(InheritsOpaqueTemplate, wow) - 408usize]; +}; +impl Default for InheritsOpaqueTemplate { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/opaque-template-instantiation-namespaced.rs b/bindgen-tests/tests/expectations/tests/opaque-template-instantiation-namespaced.rs new file mode 100644 index 0000000000..58644e053d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/opaque-template-instantiation-namespaced.rs @@ -0,0 +1,101 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod zoidberg { + #[allow(unused_imports)] + use self::super::super::root; + #[repr(C)] + #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] + pub struct Template { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub member: T, + } + impl Default for Template { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] + pub struct Foo { + pub c: ::std::os::raw::c_char, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; + ["Offset of field: Foo::c"][::std::mem::offset_of!(Foo, c) - 0usize]; + }; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] + pub struct Bar { + pub i: ::std::os::raw::c_int, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 4usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Bar::i"][::std::mem::offset_of!(Bar, i) - 0usize]; + }; + #[repr(C)] + #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] + pub struct ContainsInstantiation { + pub not_opaque: root::zoidberg::Template, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + [ + "Size of ContainsInstantiation", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of ContainsInstantiation", + ][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: ContainsInstantiation::not_opaque", + ][::std::mem::offset_of!(ContainsInstantiation, not_opaque) - 0usize]; + }; + impl Default for ContainsInstantiation { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] + pub struct ContainsOpaqueInstantiation { + pub opaque: u32, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + [ + "Size of ContainsOpaqueInstantiation", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of ContainsOpaqueInstantiation", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: ContainsOpaqueInstantiation::opaque", + ][::std::mem::offset_of!(ContainsOpaqueInstantiation, opaque) - 0usize]; + }; + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + [ + "Size of template specialization: Template_open0_Foo_close0", + ][::std::mem::size_of::>() + - 1usize]; + [ + "Align of template specialization: Template_open0_Foo_close0", + ][::std::mem::align_of::>() + - 1usize]; + }; +} diff --git a/bindgen-tests/tests/expectations/tests/opaque-template-instantiation.rs b/bindgen-tests/tests/expectations/tests/opaque-template-instantiation.rs new file mode 100644 index 0000000000..ab68c21856 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/opaque-template-instantiation.rs @@ -0,0 +1,68 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Template { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub member: T, +} +impl Default for Template { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct ContainsInstantiation { + pub not_opaque: Template<::std::os::raw::c_char>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of ContainsInstantiation", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of ContainsInstantiation", + ][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: ContainsInstantiation::not_opaque", + ][::std::mem::offset_of!(ContainsInstantiation, not_opaque) - 0usize]; +}; +impl Default for ContainsInstantiation { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct ContainsOpaqueInstantiation { + pub opaque: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of ContainsOpaqueInstantiation", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of ContainsOpaqueInstantiation", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: ContainsOpaqueInstantiation::opaque", + ][::std::mem::offset_of!(ContainsOpaqueInstantiation, opaque) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: Template_open0_char_close0", + ][::std::mem::size_of::>() - 1usize]; + [ + "Align of template specialization: Template_open0_char_close0", + ][::std::mem::align_of::>() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/opaque-tracing.rs b/bindgen-tests/tests/expectations/tests/opaque-tracing.rs new file mode 100644 index 0000000000..60d249a88c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/opaque-tracing.rs @@ -0,0 +1,16 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + #[link_name = "\u{1}_Z3fooP9Container"] + pub fn foo(c: *mut Container); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Container { + pub _bindgen_opaque_blob: [u32; 2usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Container"][::std::mem::size_of::() - 8usize]; + ["Alignment of Container"][::std::mem::align_of::() - 4usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/opaque_in_struct.rs b/bindgen-tests/tests/expectations/tests/opaque_in_struct.rs new file mode 100644 index 0000000000..b651cd3354 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/opaque_in_struct.rs @@ -0,0 +1,26 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +///
+#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct opaque { + pub _bindgen_opaque_blob: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of opaque"][::std::mem::size_of::() - 4usize]; + ["Alignment of opaque"][::std::mem::align_of::() - 4usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct container { + pub contained: opaque, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of container"][::std::mem::size_of::() - 4usize]; + ["Alignment of container"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: container::contained", + ][::std::mem::offset_of!(container, contained) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/opaque_pointer.rs b/bindgen-tests/tests/expectations/tests/opaque_pointer.rs new file mode 100644 index 0000000000..ec519d9c6b --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/opaque_pointer.rs @@ -0,0 +1,49 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +///
+#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct OtherOpaque { + pub _bindgen_opaque_blob: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of OtherOpaque"][::std::mem::size_of::() - 4usize]; + ["Alignment of OtherOpaque"][::std::mem::align_of::() - 4usize]; +}; +///
+#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Opaque { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq)] +pub struct WithOpaquePtr { + pub whatever: *mut u8, + pub other: u32, + pub t: OtherOpaque, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of WithOpaquePtr"][::std::mem::size_of::() - 16usize]; + ["Alignment of WithOpaquePtr"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: WithOpaquePtr::whatever", + ][::std::mem::offset_of!(WithOpaquePtr, whatever) - 0usize]; + [ + "Offset of field: WithOpaquePtr::other", + ][::std::mem::offset_of!(WithOpaquePtr, other) - 8usize]; + [ + "Offset of field: WithOpaquePtr::t", + ][::std::mem::offset_of!(WithOpaquePtr, t) - 12usize]; +}; +impl Default for WithOpaquePtr { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/opaque_typedef.rs b/bindgen-tests/tests/expectations/tests/opaque_typedef.rs new file mode 100644 index 0000000000..90c3b709e3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/opaque_typedef.rs @@ -0,0 +1,9 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct RandomTemplate { + pub _address: u8, +} +///
+pub type ShouldBeOpaque = u8; +pub type ShouldNotBeOpaque = RandomTemplate; diff --git a/bindgen-tests/tests/expectations/tests/opencl_vector.rs b/bindgen-tests/tests/expectations/tests/opencl_vector.rs new file mode 100644 index 0000000000..3c2525c845 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/opencl_vector.rs @@ -0,0 +1,6 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type float4 = [f32; 4usize]; +pub type float2 = [f32; 2usize]; +unsafe extern "C" { + pub fn foo(a: float2, b: float2) -> float4; +} diff --git a/bindgen-tests/tests/expectations/tests/operator.rs b/bindgen-tests/tests/expectations/tests/operator.rs new file mode 100644 index 0000000000..ce5a652d8d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/operator.rs @@ -0,0 +1,10 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + #[link_name = "\u{1}_Z20operator_informationv"] + pub fn operator_information() -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Foo { + _unused: [u8; 0], +} diff --git a/bindgen-tests/tests/expectations/tests/operator_equals.rs b/bindgen-tests/tests/expectations/tests/operator_equals.rs new file mode 100644 index 0000000000..ff9f4fdd22 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/operator_equals.rs @@ -0,0 +1,24 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct SomeClass { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of SomeClass"][::std::mem::size_of::() - 1usize]; + ["Alignment of SomeClass"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN9SomeClassaSERKS_"] + pub fn SomeClass_operatorequals( + this: *mut SomeClass, + another: *const SomeClass, + ) -> bool; +} +impl SomeClass { + #[inline] + pub unsafe fn operatorequals(&mut self, another: *const SomeClass) -> bool { + SomeClass_operatorequals(self, another) + } +} diff --git a/bindgen-tests/tests/expectations/tests/ord-enum.rs b/bindgen-tests/tests/expectations/tests/ord-enum.rs new file mode 100644 index 0000000000..aa2e67ab91 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/ord-enum.rs @@ -0,0 +1,17 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)] +pub enum A { + A0 = 0, + A1 = 1, + A2 = 2, + A3 = -1, +} +#[repr(i32)] +#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)] +pub enum B { + B0 = 1, + B1 = 4, + B2 = 3, + B3 = -1, +} diff --git a/bindgen-tests/tests/expectations/tests/overflowed_enum.rs b/bindgen-tests/tests/expectations/tests/overflowed_enum.rs new file mode 100644 index 0000000000..2c67ba6903 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/overflowed_enum.rs @@ -0,0 +1,14 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum Foo { + BAP_ARM = 9698489, + BAP_X86 = 11960045, + BAP_X86_64 = 3128633167, +} +#[repr(u16)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum Bar { + One = 1, + Big = 2, +} diff --git a/bindgen-tests/tests/expectations/tests/overloading.rs b/bindgen-tests/tests/expectations/tests/overloading.rs new file mode 100644 index 0000000000..96504b38eb --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/overloading.rs @@ -0,0 +1,17 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + #[link_name = "\u{1}_Z8Evaluatec"] + pub fn Evaluate(r: ::std::os::raw::c_char) -> bool; +} +unsafe extern "C" { + #[link_name = "\u{1}_Z8Evaluateii"] + pub fn Evaluate1(x: ::std::os::raw::c_int, y: ::std::os::raw::c_int) -> bool; +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN3foo10MyFunctionEv"] + pub fn foo_MyFunction(); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN3bar10MyFunctionEv"] + pub fn bar_MyFunction(); +} diff --git a/bindgen-tests/tests/expectations/tests/packed-bitfield.rs b/bindgen-tests/tests/expectations/tests/packed-bitfield.rs new file mode 100644 index 0000000000..b5a734454a --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/packed-bitfield.rs @@ -0,0 +1,301 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C, packed)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Date { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Date"][::std::mem::size_of::() - 3usize]; + ["Alignment of Date"][::std::mem::align_of::() - 1usize]; +}; +impl Date { + #[inline] + pub fn day(&self) -> ::std::os::raw::c_uchar { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u8) } + } + #[inline] + pub fn set_day(&mut self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn day_raw(this: *const Self) -> ::std::os::raw::c_uchar { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 5u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_day_raw(this: *mut Self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn month(&self) -> ::std::os::raw::c_uchar { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 4u8) as u8) } + } + #[inline] + pub fn set_month(&mut self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn month_raw(this: *const Self) -> ::std::os::raw::c_uchar { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 5usize, 4u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_month_raw(this: *mut Self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn year(&self) -> ::std::os::raw::c_short { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 15u8) as u16) } + } + #[inline] + pub fn set_year(&mut self, val: ::std::os::raw::c_short) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 15u8, val as u64) + } + } + #[inline] + pub unsafe fn year_raw(this: *const Self) -> ::std::os::raw::c_short { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 9usize, 15u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_year_raw(this: *mut Self, val: ::std::os::raw::c_short) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 3usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 9usize, + 15u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + day: ::std::os::raw::c_uchar, + month: ::std::os::raw::c_uchar, + year: ::std::os::raw::c_short, + ) -> __BindgenBitfieldUnit<[u8; 3usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 5u8, + { + let day: u8 = unsafe { ::std::mem::transmute(day) }; + day as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 5usize, + 4u8, + { + let month: u8 = unsafe { ::std::mem::transmute(month) }; + month as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 9usize, + 15u8, + { + let year: u16 = unsafe { ::std::mem::transmute(year) }; + year as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/packed-n-with-padding.rs b/bindgen-tests/tests/expectations/tests/packed-n-with-padding.rs new file mode 100644 index 0000000000..162a1bebed --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/packed-n-with-padding.rs @@ -0,0 +1,18 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C, packed(2))] +#[derive(Debug, Default, Copy, Clone)] +pub struct Packed { + pub a: ::std::os::raw::c_char, + pub b: ::std::os::raw::c_short, + pub c: ::std::os::raw::c_char, + pub d: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Packed"][::std::mem::size_of::() - 10usize]; + ["Alignment of Packed"][::std::mem::align_of::() - 2usize]; + ["Offset of field: Packed::a"][::std::mem::offset_of!(Packed, a) - 0usize]; + ["Offset of field: Packed::b"][::std::mem::offset_of!(Packed, b) - 2usize]; + ["Offset of field: Packed::c"][::std::mem::offset_of!(Packed, c) - 4usize]; + ["Offset of field: Packed::d"][::std::mem::offset_of!(Packed, d) - 6usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/packed-vtable.rs b/bindgen-tests/tests/expectations/tests/packed-vtable.rs new file mode 100644 index 0000000000..71e1956d88 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/packed-vtable.rs @@ -0,0 +1,26 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(feature = "nightly")] +#[repr(C)] +pub struct PackedVtable__bindgen_vtable(::std::os::raw::c_void); +#[repr(C, packed)] +pub struct PackedVtable { + pub vtable_: *const PackedVtable__bindgen_vtable, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of PackedVtable"][::std::mem::size_of::() - 8usize]; + ["Alignment of PackedVtable"][::std::mem::align_of::() - 1usize]; +}; +impl Default for PackedVtable { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN12PackedVtableD1Ev"] + pub fn PackedVtable_PackedVtable_destructor(this: *mut PackedVtable); +} diff --git a/bindgen-tests/tests/expectations/tests/parm-union.rs b/bindgen-tests/tests/expectations/tests/parm-union.rs new file mode 100644 index 0000000000..6dee4ec7d5 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/parm-union.rs @@ -0,0 +1,26 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Struct { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Struct"][::std::mem::size_of::() - 1usize]; + ["Alignment of Struct"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN6Struct8FunctionER5Union"] + pub fn Struct_Function(this: *mut Struct, arg1: *mut Union); +} +impl Struct { + #[inline] + pub unsafe fn Function(&mut self, arg1: *mut Union) { + Struct_Function(self, arg1) + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Union { + _unused: [u8; 0], +} diff --git a/bindgen-tests/tests/expectations/tests/parsecb-anonymous-enum-variant-rename.rs b/bindgen-tests/tests/expectations/tests/parsecb-anonymous-enum-variant-rename.rs new file mode 100644 index 0000000000..98c10d7ec5 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/parsecb-anonymous-enum-variant-rename.rs @@ -0,0 +1,3 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const RENAMED_MyVal: _bindgen_ty_1 = 0; +pub type _bindgen_ty_1 = ::std::os::raw::c_uint; diff --git a/bindgen-tests/tests/expectations/tests/partial-specialization-and-inheritance.rs b/bindgen-tests/tests/expectations/tests/partial-specialization-and-inheritance.rs new file mode 100644 index 0000000000..cba5cfbb52 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/partial-specialization-and-inheritance.rs @@ -0,0 +1,33 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)] +#[repr(C)] +pub struct __BindgenOpaqueArray(pub T); +impl Default for __BindgenOpaqueArray<[T; N]> { + fn default() -> Self { + Self([::default(); N]) + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Base { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Derived { + pub b: bool, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Usage { + pub _address: u8, +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN5Usage13static_memberE"] + pub static mut Usage_static_member: __BindgenOpaqueArray<[u32; 2usize]>; +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Usage"][::std::mem::size_of::() - 1usize]; + ["Alignment of Usage"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/pointer-attr.rs b/bindgen-tests/tests/expectations/tests/pointer-attr.rs new file mode 100644 index 0000000000..4d7e250b9c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/pointer-attr.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn a(arg1: *const ::std::os::raw::c_char); +} diff --git a/bindgen-tests/tests/expectations/tests/prefix-link-name-c.rs b/bindgen-tests/tests/expectations/tests/prefix-link-name-c.rs new file mode 100644 index 0000000000..cb1ebfa4f7 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/prefix-link-name-c.rs @@ -0,0 +1,5 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + #[link_name = "\u{1}foo_bar"] + pub fn bar() -> ::std::os::raw::c_int; +} diff --git a/bindgen-tests/tests/expectations/tests/prefix-link-name-cpp.rs b/bindgen-tests/tests/expectations/tests/prefix-link-name-cpp.rs new file mode 100644 index 0000000000..07cacc5f7a --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/prefix-link-name-cpp.rs @@ -0,0 +1,5 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + #[link_name = "\u{1}foo_foo"] + pub fn baz_foo() -> ::std::os::raw::c_int; +} diff --git a/bindgen-tests/tests/expectations/tests/prepend-enum-constified-variant.rs b/bindgen-tests/tests/expectations/tests/prepend-enum-constified-variant.rs new file mode 100644 index 0000000000..ff49d684f1 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/prepend-enum-constified-variant.rs @@ -0,0 +1,9 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +impl AVCodecID { + pub const AV_CODEC_ID_TTF: AVCodecID = AVCodecID::AV_CODEC_ID_FIRST_UNKNOWN; +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum AVCodecID { + AV_CODEC_ID_FIRST_UNKNOWN = 98304, +} diff --git a/bindgen-tests/tests/expectations/tests/prepend_enum_name.rs b/bindgen-tests/tests/expectations/tests/prepend_enum_name.rs new file mode 100644 index 0000000000..b4201a8cd9 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/prepend_enum_name.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const FOO_BAR: foo = 0; +pub const FOO_BAZ: foo = 1; +pub type foo = ::std::os::raw::c_uint; diff --git a/bindgen-tests/tests/expectations/tests/private.rs b/bindgen-tests/tests/expectations/tests/private.rs new file mode 100644 index 0000000000..bf1e853e6a --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/private.rs @@ -0,0 +1,58 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct HasPrivate { + pub mNotPrivate: ::std::os::raw::c_int, + ///
+ mIsPrivate: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of HasPrivate"][::std::mem::size_of::() - 8usize]; + ["Alignment of HasPrivate"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: HasPrivate::mNotPrivate", + ][::std::mem::offset_of!(HasPrivate, mNotPrivate) - 0usize]; + [ + "Offset of field: HasPrivate::mIsPrivate", + ][::std::mem::offset_of!(HasPrivate, mIsPrivate) - 4usize]; +}; +///
+#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct VeryPrivate { + mIsPrivate: ::std::os::raw::c_int, + mIsAlsoPrivate: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of VeryPrivate"][::std::mem::size_of::() - 8usize]; + ["Alignment of VeryPrivate"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: VeryPrivate::mIsPrivate", + ][::std::mem::offset_of!(VeryPrivate, mIsPrivate) - 0usize]; + [ + "Offset of field: VeryPrivate::mIsAlsoPrivate", + ][::std::mem::offset_of!(VeryPrivate, mIsAlsoPrivate) - 4usize]; +}; +///
+#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct ContradictPrivate { + ///
+ pub mNotPrivate: ::std::os::raw::c_int, + mIsPrivate: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ContradictPrivate"][::std::mem::size_of::() - 8usize]; + [ + "Alignment of ContradictPrivate", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: ContradictPrivate::mNotPrivate", + ][::std::mem::offset_of!(ContradictPrivate, mNotPrivate) - 0usize]; + [ + "Offset of field: ContradictPrivate::mIsPrivate", + ][::std::mem::offset_of!(ContradictPrivate, mIsPrivate) - 4usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/private_fields.rs b/bindgen-tests/tests/expectations/tests/private_fields.rs new file mode 100644 index 0000000000..abb2886d39 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/private_fields.rs @@ -0,0 +1,788 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct PubPriv { + pub x: ::std::os::raw::c_int, + y: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of PubPriv"][::std::mem::size_of::() - 8usize]; + ["Alignment of PubPriv"][::std::mem::align_of::() - 4usize]; + ["Offset of field: PubPriv::x"][::std::mem::offset_of!(PubPriv, x) - 0usize]; + ["Offset of field: PubPriv::y"][::std::mem::offset_of!(PubPriv, y) - 4usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct PrivateBitFields { + pub _bindgen_align: [u32; 0], + _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of PrivateBitFields"][::std::mem::size_of::() - 4usize]; + [ + "Alignment of PrivateBitFields", + ][::std::mem::align_of::() - 4usize]; +}; +impl PrivateBitFields { + #[inline] + fn a(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } + } + #[inline] + fn set_a(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + unsafe fn a_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 4u8) + as u32, + ) + } + } + #[inline] + unsafe fn set_a_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + fn b(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32) } + } + #[inline] + fn set_b(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 4u8, val as u64) + } + } + #[inline] + unsafe fn b_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 4u8) + as u32, + ) + } + } + #[inline] + unsafe fn set_b_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 4u8, + val as u64, + ) + } + } + #[inline] + fn new_bitfield_1( + a: ::std::os::raw::c_uint, + b: ::std::os::raw::c_uint, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 4u8, + { + let a: u32 = unsafe { ::std::mem::transmute(a) }; + a as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 4usize, + 4u8, + { + let b: u32 = unsafe { ::std::mem::transmute(b) }; + b as u64 + }, + ); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct PublicBitFields { + pub _bindgen_align: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of PublicBitFields"][::std::mem::size_of::() - 4usize]; + ["Alignment of PublicBitFields"][::std::mem::align_of::() - 4usize]; +}; +impl PublicBitFields { + #[inline] + pub fn a(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } + } + #[inline] + pub fn set_a(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn a_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 4u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_a_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn b(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32) } + } + #[inline] + pub fn set_b(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn b_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 4u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_b_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + a: ::std::os::raw::c_uint, + b: ::std::os::raw::c_uint, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 4u8, + { + let a: u32 = unsafe { ::std::mem::transmute(a) }; + a as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 4usize, + 4u8, + { + let b: u32 = unsafe { ::std::mem::transmute(b) }; + b as u64 + }, + ); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct MixedBitFields { + pub _bindgen_align: [u32; 0], + _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of MixedBitFields"][::std::mem::size_of::() - 4usize]; + ["Alignment of MixedBitFields"][::std::mem::align_of::() - 4usize]; +}; +impl MixedBitFields { + #[inline] + fn a(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } + } + #[inline] + fn set_a(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + unsafe fn a_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 4u8) + as u32, + ) + } + } + #[inline] + unsafe fn set_a_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn d(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32) } + } + #[inline] + pub fn set_d(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn d_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 4u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_d_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 4u8, + val as u64, + ) + } + } + #[inline] + fn new_bitfield_1( + a: ::std::os::raw::c_uint, + d: ::std::os::raw::c_uint, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 4u8, + { + let a: u32 = unsafe { ::std::mem::transmute(a) }; + a as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 4usize, + 4u8, + { + let d: u32 = unsafe { ::std::mem::transmute(d) }; + d as u64 + }, + ); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Base { + pub member: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Base"][::std::mem::size_of::() - 4usize]; + ["Alignment of Base"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Base::member"][::std::mem::offset_of!(Base, member) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct InheritsPrivately { + _base: Base, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of InheritsPrivately"][::std::mem::size_of::() - 4usize]; + [ + "Alignment of InheritsPrivately", + ][::std::mem::align_of::() - 4usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct InheritsPublically { + pub _base: Base, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of InheritsPublically"][::std::mem::size_of::() - 4usize]; + [ + "Alignment of InheritsPublically", + ][::std::mem::align_of::() - 4usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct WithAnonStruct { + __bindgen_anon_1: WithAnonStruct__bindgen_ty_1, + pub __bindgen_anon_2: WithAnonStruct__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct WithAnonStruct__bindgen_ty_1 { + pub a: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of WithAnonStruct__bindgen_ty_1", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of WithAnonStruct__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: WithAnonStruct__bindgen_ty_1::a", + ][::std::mem::offset_of!(WithAnonStruct__bindgen_ty_1, a) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct WithAnonStruct__bindgen_ty_2 { + pub b: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of WithAnonStruct__bindgen_ty_2", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of WithAnonStruct__bindgen_ty_2", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: WithAnonStruct__bindgen_ty_2::b", + ][::std::mem::offset_of!(WithAnonStruct__bindgen_ty_2, b) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of WithAnonStruct"][::std::mem::size_of::() - 8usize]; + ["Alignment of WithAnonStruct"][::std::mem::align_of::() - 4usize]; +}; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct WithAnonUnion { + __bindgen_anon_1: WithAnonUnion__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union WithAnonUnion__bindgen_ty_1 { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of WithAnonUnion__bindgen_ty_1", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of WithAnonUnion__bindgen_ty_1", + ][::std::mem::align_of::() - 1usize]; +}; +impl Default for WithAnonUnion__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of WithAnonUnion"][::std::mem::size_of::() - 1usize]; + ["Alignment of WithAnonUnion"][::std::mem::align_of::() - 1usize]; +}; +impl Default for WithAnonUnion { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Override { + pub a: ::std::os::raw::c_uint, + ///
+ b: ::std::os::raw::c_uint, + private_c: ::std::os::raw::c_uint, + _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, + pub __bindgen_padding_0: u16, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Override"][::std::mem::size_of::() - 16usize]; + ["Alignment of Override"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Override::a"][::std::mem::offset_of!(Override, a) - 0usize]; + ["Offset of field: Override::b"][::std::mem::offset_of!(Override, b) - 4usize]; + [ + "Offset of field: Override::private_c", + ][::std::mem::offset_of!(Override, private_c) - 8usize]; +}; +impl Override { + #[inline] + pub fn bf_a(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } + } + #[inline] + pub fn set_bf_a(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn bf_a_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 4u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bf_a_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + fn bf_b(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32) } + } + #[inline] + fn set_bf_b(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 4u8, val as u64) + } + } + #[inline] + unsafe fn bf_b_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 4u8) + as u32, + ) + } + } + #[inline] + unsafe fn set_bf_b_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 4u8, + val as u64, + ) + } + } + #[inline] + fn private_bf_c(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u32) } + } + #[inline] + fn set_private_bf_c(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 4u8, val as u64) + } + } + #[inline] + unsafe fn private_bf_c_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 8usize, 4u8) + as u32, + ) + } + } + #[inline] + unsafe fn set_private_bf_c_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 4u8, + val as u64, + ) + } + } + #[inline] + fn new_bitfield_1( + bf_a: ::std::os::raw::c_uint, + bf_b: ::std::os::raw::c_uint, + private_bf_c: ::std::os::raw::c_uint, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 4u8, + { + let bf_a: u32 = unsafe { ::std::mem::transmute(bf_a) }; + bf_a as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 4usize, + 4u8, + { + let bf_b: u32 = unsafe { ::std::mem::transmute(bf_b) }; + bf_b as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 8usize, + 4u8, + { + let private_bf_c: u32 = unsafe { + ::std::mem::transmute(private_bf_c) + }; + private_bf_c as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/ptr32-has-different-size.rs b/bindgen-tests/tests/expectations/tests/ptr32-has-different-size.rs new file mode 100644 index 0000000000..f4f3ab4294 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/ptr32-has-different-size.rs @@ -0,0 +1,24 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct TEST_STRUCT { + pub ptr_32bit: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of TEST_STRUCT"][::std::mem::size_of::() - 4usize]; + ["Alignment of TEST_STRUCT"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: TEST_STRUCT::ptr_32bit", + ][::std::mem::offset_of!(TEST_STRUCT, ptr_32bit) - 0usize]; +}; +impl Default for TEST_STRUCT { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type TEST = TEST_STRUCT; diff --git a/bindgen-tests/tests/expectations/tests/public-dtor.rs b/bindgen-tests/tests/expectations/tests/public-dtor.rs new file mode 100644 index 0000000000..578d3e76a5 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/public-dtor.rs @@ -0,0 +1,31 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default)] +pub struct cv_Foo { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of cv_Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of cv_Foo"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN2cv3FooD1Ev"] + pub fn cv_Foo_Foo_destructor(this: *mut cv_Foo); +} +impl cv_Foo { + #[inline] + pub unsafe fn destruct(&mut self) { + cv_Foo_Foo_destructor(self) + } +} +#[repr(C)] +#[derive(Debug, Default)] +pub struct cv_Bar { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of cv_Bar"][::std::mem::size_of::() - 1usize]; + ["Alignment of cv_Bar"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/qualified-dependent-types.rs b/bindgen-tests/tests/expectations/tests/qualified-dependent-types.rs new file mode 100644 index 0000000000..9bbbddd88d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/qualified-dependent-types.rs @@ -0,0 +1,11 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Bar { + pub _address: u8, +} diff --git a/bindgen-tests/tests/expectations/tests/redeclaration.rs b/bindgen-tests/tests/expectations/tests/redeclaration.rs new file mode 100644 index 0000000000..736d379f01 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/redeclaration.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn foo(); +} diff --git a/bindgen-tests/tests/expectations/tests/redundant-packed-and-align.rs b/bindgen-tests/tests/expectations/tests/redundant-packed-and-align.rs new file mode 100644 index 0000000000..05401e52ca --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/redundant-packed-and-align.rs @@ -0,0 +1,372 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[repr(align(8))] +#[derive(Debug, Default, Copy, Clone)] +pub struct redundant_packed { + pub a: u32, + pub b: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of redundant_packed"][::std::mem::size_of::() - 8usize]; + [ + "Alignment of redundant_packed", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: redundant_packed::a", + ][::std::mem::offset_of!(redundant_packed, a) - 0usize]; + [ + "Offset of field: redundant_packed::b", + ][::std::mem::offset_of!(redundant_packed, b) - 4usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct redundant_packed_bitfield { + pub _bindgen_align: [u64; 0], + pub a: [u8; 3usize], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub c: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of redundant_packed_bitfield", + ][::std::mem::size_of::() - 8usize]; + [ + "Alignment of redundant_packed_bitfield", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: redundant_packed_bitfield::a", + ][::std::mem::offset_of!(redundant_packed_bitfield, a) - 0usize]; + [ + "Offset of field: redundant_packed_bitfield::c", + ][::std::mem::offset_of!(redundant_packed_bitfield, c) - 4usize]; +}; +impl redundant_packed_bitfield { + #[inline] + pub fn b0(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_b0(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn b0_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_b0_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn b1(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } + } + #[inline] + pub fn set_b1(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn b1_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_b1_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(b0: u8, b1: u8) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let b0: u8 = unsafe { ::std::mem::transmute(b0) }; + b0 as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 1u8, + { + let b1: u8 = unsafe { ::std::mem::transmute(b1) }; + b1 as u64 + }, + ); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub union redundant_packed_union { + pub a: u64, + pub b: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of redundant_packed_union", + ][::std::mem::size_of::() - 16usize]; + [ + "Alignment of redundant_packed_union", + ][::std::mem::align_of::() - 16usize]; + [ + "Offset of field: redundant_packed_union::a", + ][::std::mem::offset_of!(redundant_packed_union, a) - 0usize]; + [ + "Offset of field: redundant_packed_union::b", + ][::std::mem::offset_of!(redundant_packed_union, b) - 0usize]; +}; +impl Default for redundant_packed_union { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[repr(align(2))] +#[derive(Debug, Default, Copy, Clone)] +pub struct inner { + pub a: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of inner"][::std::mem::size_of::() - 2usize]; + ["Alignment of inner"][::std::mem::align_of::() - 2usize]; + ["Offset of field: inner::a"][::std::mem::offset_of!(inner, a) - 0usize]; +}; +#[repr(C)] +#[repr(align(8))] +#[derive(Debug, Default, Copy, Clone)] +pub struct outer_redundant_packed { + pub a: [inner; 2usize], + pub b: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of outer_redundant_packed", + ][::std::mem::size_of::() - 8usize]; + [ + "Alignment of outer_redundant_packed", + ][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: outer_redundant_packed::a", + ][::std::mem::offset_of!(outer_redundant_packed, a) - 0usize]; + [ + "Offset of field: outer_redundant_packed::b", + ][::std::mem::offset_of!(outer_redundant_packed, b) - 4usize]; +}; +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Default, Copy, Clone)] +pub struct redundant_pragma_packed { + pub a: u8, + pub b: u16, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of redundant_pragma_packed", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of redundant_pragma_packed", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: redundant_pragma_packed::a", + ][::std::mem::offset_of!(redundant_pragma_packed, a) - 0usize]; + [ + "Offset of field: redundant_pragma_packed::b", + ][::std::mem::offset_of!(redundant_pragma_packed, b) - 2usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/ref_argument_array.rs b/bindgen-tests/tests/expectations/tests/ref_argument_array.rs new file mode 100644 index 0000000000..4928a185fe --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/ref_argument_array.rs @@ -0,0 +1,35 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const NSID_LENGTH: u32 = 10; +#[repr(C)] +pub struct nsID__bindgen_vtable { + pub nsID_ToProvidedString: unsafe extern "C" fn( + this: *mut nsID, + aDest: *mut [::std::os::raw::c_char; 10usize], + ), +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nsID { + pub vtable_: *const nsID__bindgen_vtable, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of nsID"][::std::mem::size_of::() - 8usize]; + ["Alignment of nsID"][::std::mem::align_of::() - 8usize]; +}; +impl Default for nsID { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN4nsID16ToProvidedStringERA10_c"] + pub fn nsID_ToProvidedString( + this: *mut ::std::os::raw::c_void, + aDest: *mut [::std::os::raw::c_char; 10usize], + ); +} diff --git a/bindgen-tests/tests/expectations/tests/references.rs b/bindgen-tests/tests/expectations/tests/references.rs new file mode 100644 index 0000000000..799e855793 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/references.rs @@ -0,0 +1,61 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Container { + pub normalPointer: *mut ::std::os::raw::c_int, + pub constPointer: *const ::std::os::raw::c_int, + pub normalRef: ::std::ptr::NonNull<::std::os::raw::c_int>, + pub constRef: ::std::ptr::NonNull<::std::os::raw::c_int>, + pub pointerRef: ::std::ptr::NonNull<*mut ::std::os::raw::c_int>, + pub constPointerRef: ::std::ptr::NonNull<*const ::std::os::raw::c_int>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Container"][::std::mem::size_of::() - 48usize]; + ["Alignment of Container"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: Container::normalPointer", + ][::std::mem::offset_of!(Container, normalPointer) - 0usize]; + [ + "Offset of field: Container::constPointer", + ][::std::mem::offset_of!(Container, constPointer) - 8usize]; + [ + "Offset of field: Container::normalRef", + ][::std::mem::offset_of!(Container, normalRef) - 16usize]; + [ + "Offset of field: Container::constRef", + ][::std::mem::offset_of!(Container, constRef) - 24usize]; + [ + "Offset of field: Container::pointerRef", + ][::std::mem::offset_of!(Container, pointerRef) - 32usize]; + [ + "Offset of field: Container::constPointerRef", + ][::std::mem::offset_of!(Container, constPointerRef) - 40usize]; +}; +impl Default for Container { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +unsafe extern "C" { + #[link_name = "\u{1}_Z20refReturningFunctionv"] + pub fn refReturningFunction() -> ::std::ptr::NonNull<::std::os::raw::c_int>; +} +unsafe extern "C" { + #[link_name = "\u{1}_Z20functionConsumingRefRifRKi"] + pub fn functionConsumingRef( + someRef: ::std::ptr::NonNull<::std::os::raw::c_int>, + normalArgument: f32, + constRef: ::std::ptr::NonNull<::std::os::raw::c_int>, + ); +} +unsafe extern "C" { + #[link_name = "\u{1}_Z27functionConsumingPointerRefRPi"] + pub fn functionConsumingPointerRef( + pointerRef: ::std::ptr::NonNull<*mut ::std::os::raw::c_int>, + ); +} diff --git a/bindgen-tests/tests/expectations/tests/reparented_replacement.rs b/bindgen-tests/tests/expectations/tests/reparented_replacement.rs new file mode 100644 index 0000000000..9b2cc33ce9 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/reparented_replacement.rs @@ -0,0 +1,23 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod foo { + #[allow(unused_imports)] + use self::super::super::root; + ///
+ #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Bar { + pub bazz: ::std::os::raw::c_int, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 4usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Bar::bazz"][::std::mem::offset_of!(Bar, bazz) - 0usize]; + }; + } + pub type ReferencesBar = root::foo::Bar; +} diff --git a/bindgen-tests/tests/expectations/tests/replace_template_alias.rs b/bindgen-tests/tests/expectations/tests/replace_template_alias.rs new file mode 100644 index 0000000000..2efa164ddf --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/replace_template_alias.rs @@ -0,0 +1,20 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +/** But the replacement type does use T! + +
*/ +pub type JS_detail_MaybeWrapped = T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct JS_Rooted { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub ptr: JS_detail_MaybeWrapped, +} +impl Default for JS_Rooted { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/replace_use.rs b/bindgen-tests/tests/expectations/tests/replace_use.rs new file mode 100644 index 0000000000..ebf9657176 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/replace_use.rs @@ -0,0 +1,27 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +///
+#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct nsTArray { + pub y: ::std::os::raw::c_uint, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Test { + pub a: nsTArray, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Test"][::std::mem::size_of::() - 4usize]; + ["Alignment of Test"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Test::a"][::std::mem::offset_of!(Test, a) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: nsTArray_open0_long_close0", + ][::std::mem::size_of::() - 4usize]; + [ + "Align of template specialization: nsTArray_open0_long_close0", + ][::std::mem::align_of::() - 4usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/replaces_double.rs b/bindgen-tests/tests/expectations/tests/replaces_double.rs new file mode 100644 index 0000000000..e764113f21 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/replaces_double.rs @@ -0,0 +1,34 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Wrapper_Wrapped { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub t: T, +} +impl Default for Wrapper_Wrapped { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type Wrapper_Type = Wrapper_Wrapped; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Rooted { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub ptr: Rooted_MaybeWrapped, +} +///
+pub type Rooted_MaybeWrapped = T; +impl Default for Rooted { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/repr-align.rs b/bindgen-tests/tests/expectations/tests/repr-align.rs new file mode 100644 index 0000000000..867a28cc78 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/repr-align.rs @@ -0,0 +1,30 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(feature = "nightly")] +#[repr(C)] +#[repr(align(8))] +#[derive(Debug, Default, Copy, Clone)] +pub struct a { + pub b: ::std::os::raw::c_int, + pub c: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of a"][::std::mem::size_of::() - 8usize]; + ["Alignment of a"][::std::mem::align_of::() - 8usize]; + ["Offset of field: a::b"][::std::mem::offset_of!(a, b) - 0usize]; + ["Offset of field: a::c"][::std::mem::offset_of!(a, c) - 4usize]; +}; +#[repr(C)] +#[repr(align(8))] +#[derive(Debug, Default, Copy, Clone)] +pub struct b { + pub b: ::std::os::raw::c_int, + pub c: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of b"][::std::mem::size_of::() - 8usize]; + ["Alignment of b"][::std::mem::align_of::() - 8usize]; + ["Offset of field: b::b"][::std::mem::offset_of!(b, b) - 0usize]; + ["Offset of field: b::c"][::std::mem::offset_of!(b, c) - 4usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/resolved_type_def_function.rs b/bindgen-tests/tests/expectations/tests/resolved_type_def_function.rs new file mode 100644 index 0000000000..cfbab6b968 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/resolved_type_def_function.rs @@ -0,0 +1,5 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type FuncType = ::std::option::Option; +unsafe extern "C" { + pub fn Func(); +} diff --git a/bindgen-tests/tests/expectations/tests/same_struct_name_in_different_namespaces.rs b/bindgen-tests/tests/expectations/tests/same_struct_name_in_different_namespaces.rs new file mode 100644 index 0000000000..e6e4088abf --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/same_struct_name_in_different_namespaces.rs @@ -0,0 +1,23 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct JS_Zone { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct JS_shadow_Zone { + pub x: ::std::os::raw::c_int, + pub y: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of JS_shadow_Zone"][::std::mem::size_of::() - 8usize]; + ["Alignment of JS_shadow_Zone"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: JS_shadow_Zone::x", + ][::std::mem::offset_of!(JS_shadow_Zone, x) - 0usize]; + [ + "Offset of field: JS_shadow_Zone::y", + ][::std::mem::offset_of!(JS_shadow_Zone, y) - 4usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/sentry-defined-multiple-times.rs b/bindgen-tests/tests/expectations/tests/sentry-defined-multiple-times.rs new file mode 100644 index 0000000000..0fe153e700 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/sentry-defined-multiple-times.rs @@ -0,0 +1,235 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod whatever { + #[allow(unused_imports)] + use self::super::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Wrapper { + pub _address: u8, + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Wrapper_sentry { + pub i_am_wrapper_sentry: ::std::os::raw::c_int, + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct sentry { + pub i_am_plain_sentry: bool, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of sentry"][::std::mem::size_of::() - 1usize]; + ["Alignment of sentry"][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: sentry::i_am_plain_sentry", + ][::std::mem::offset_of!(sentry, i_am_plain_sentry) - 0usize]; + }; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct NotTemplateWrapper { + pub _address: u8, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + [ + "Size of NotTemplateWrapper", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of NotTemplateWrapper", + ][::std::mem::align_of::() - 1usize]; + }; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct NotTemplateWrapper_sentry { + pub i_am_not_template_wrapper_sentry: ::std::os::raw::c_char, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + [ + "Size of NotTemplateWrapper_sentry", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of NotTemplateWrapper_sentry", + ][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: NotTemplateWrapper_sentry::i_am_not_template_wrapper_sentry", + ][::std::mem::offset_of!( + NotTemplateWrapper_sentry, i_am_not_template_wrapper_sentry + ) - 0usize]; + }; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct InlineNotTemplateWrapper { + pub _address: u8, + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct InlineNotTemplateWrapper_sentry { + pub i_am_inline_not_template_wrapper_sentry: bool, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + [ + "Size of InlineNotTemplateWrapper_sentry", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of InlineNotTemplateWrapper_sentry", + ][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: InlineNotTemplateWrapper_sentry::i_am_inline_not_template_wrapper_sentry", + ][::std::mem::offset_of!( + InlineNotTemplateWrapper_sentry, i_am_inline_not_template_wrapper_sentry + ) - 0usize]; + }; + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + [ + "Size of InlineNotTemplateWrapper", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of InlineNotTemplateWrapper", + ][::std::mem::align_of::() - 1usize]; + }; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct InlineTemplateWrapper { + pub _address: u8, + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct InlineTemplateWrapper_sentry { + pub i_am_inline_template_wrapper_sentry: ::std::os::raw::c_int, + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct OuterDoubleWrapper { + pub _address: u8, + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct OuterDoubleWrapper_InnerDoubleWrapper { + pub _address: u8, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + [ + "Size of OuterDoubleWrapper_InnerDoubleWrapper", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of OuterDoubleWrapper_InnerDoubleWrapper", + ][::std::mem::align_of::() - 1usize]; + }; + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + [ + "Size of OuterDoubleWrapper", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of OuterDoubleWrapper", + ][::std::mem::align_of::() - 1usize]; + }; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct OuterDoubleWrapper_InnerDoubleWrapper_sentry { + pub i_am_double_wrapper_sentry: ::std::os::raw::c_int, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + [ + "Size of OuterDoubleWrapper_InnerDoubleWrapper_sentry", + ][::std::mem::size_of::() + - 4usize]; + [ + "Alignment of OuterDoubleWrapper_InnerDoubleWrapper_sentry", + ][::std::mem::align_of::() + - 4usize]; + [ + "Offset of field: OuterDoubleWrapper_InnerDoubleWrapper_sentry::i_am_double_wrapper_sentry", + ][::std::mem::offset_of!( + OuterDoubleWrapper_InnerDoubleWrapper_sentry, i_am_double_wrapper_sentry + ) - 0usize]; + }; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct OuterDoubleInlineWrapper { + pub _address: u8, + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct OuterDoubleInlineWrapper_InnerDoubleInlineWrapper { + pub _address: u8, + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry { + pub i_am_double_wrapper_inline_sentry: ::std::os::raw::c_int, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + [ + "Size of OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry", + ][::std::mem::size_of::< + OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry, + >() - 4usize]; + [ + "Alignment of OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry", + ][::std::mem::align_of::< + OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry, + >() - 4usize]; + [ + "Offset of field: OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry::i_am_double_wrapper_inline_sentry", + ][::std::mem::offset_of!( + OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry, + i_am_double_wrapper_inline_sentry + ) - 0usize]; + }; + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + [ + "Size of OuterDoubleInlineWrapper_InnerDoubleInlineWrapper", + ][::std::mem::size_of::() + - 1usize]; + [ + "Alignment of OuterDoubleInlineWrapper_InnerDoubleInlineWrapper", + ][::std::mem::align_of::() + - 1usize]; + }; + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + [ + "Size of OuterDoubleInlineWrapper", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of OuterDoubleInlineWrapper", + ][::std::mem::align_of::() - 1usize]; + }; + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct OutsideNamespaceWrapper { + pub _address: u8, + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct OutsideNamespaceWrapper_sentry { + pub i_am_outside_namespace_wrapper_sentry: ::std::os::raw::c_int, + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct sentry { + pub i_am_outside_namespace_sentry: ::std::os::raw::c_int, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of sentry"][::std::mem::size_of::() - 4usize]; + ["Alignment of sentry"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: sentry::i_am_outside_namespace_sentry", + ][::std::mem::offset_of!(sentry, i_am_outside_namespace_sentry) - 0usize]; + }; +} diff --git a/bindgen-tests/tests/expectations/tests/short-enums.rs b/bindgen-tests/tests/expectations/tests/short-enums.rs new file mode 100644 index 0000000000..493bb5b419 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/short-enums.rs @@ -0,0 +1,16 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(u8)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum one_byte_t { + SOME_VALUE = 1, +} +#[repr(u16)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum two_byte_t { + SOME_OTHER_VALUE = 256, +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum four_byte_t { + SOME_BIGGER_VALUE = 16777216, +} diff --git a/bindgen-tests/tests/expectations/tests/size_t_template.rs b/bindgen-tests/tests/expectations/tests/size_t_template.rs new file mode 100644 index 0000000000..08ffa22750 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/size_t_template.rs @@ -0,0 +1,20 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)] +#[repr(C)] +pub struct __BindgenOpaqueArray(pub T); +impl Default for __BindgenOpaqueArray<[T; N]> { + fn default() -> Self { + Self([::default(); N]) + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct C { + pub arr: __BindgenOpaqueArray<[u32; 3usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C"][::std::mem::size_of::() - 12usize]; + ["Alignment of C"][::std::mem::align_of::() - 4usize]; + ["Offset of field: C::arr"][::std::mem::offset_of!(C, arr) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/sort-items.rs b/bindgen-tests/tests/expectations/tests/sort-items.rs new file mode 100644 index 0000000000..e04e3b6090 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/sort-items.rs @@ -0,0 +1,220 @@ +#![allow( + dead_code, + non_snake_case, + non_camel_case_types, + non_upper_case_globals +)] + +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + pub type number = ::std::os::raw::c_int; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Point { + pub x: root::number, + pub y: root::number, + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Angle { + pub a: root::number, + pub b: root::number, + } + pub const NUMBER: root::number = 42; + #[test] + fn bindgen_test_layout_Point() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Point)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Point)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Point), + "::", + stringify!(x) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Point), + "::", + stringify!(y) + ) + ); + } + #[test] + fn bindgen_test_layout_Angle() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Angle)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Angle)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Angle), + "::", + stringify!(a) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Angle), + "::", + stringify!(b) + ) + ); + } + pub mod ns { + pub type number = ::std::os::raw::c_int; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Point { + pub x: root::ns::number, + pub y: root::ns::number, + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Angle { + pub a: root::ns::number, + pub b: root::ns::number, + } + pub const NUMBER: root::ns::number = 42; + #[test] + fn bindgen_test_layout_Point() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Point)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Point)) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Point), + "::", + stringify!(x) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Point), + "::", + stringify!(y) + ) + ); + } + #[test] + fn bindgen_test_layout_Angle() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Angle)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Angle)) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Angle), + "::", + stringify!(a) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Angle), + "::", + stringify!(b) + ) + ); + } + #[allow(unused_imports)] + use self::super::super::root; + extern "C" { + #[link_name = "\u{1}_ZN2ns3fooEv"] + pub fn foo() -> ::std::os::raw::c_int; + } + extern "C" { + #[link_name = "\u{1}_ZN2ns3barEi"] + pub fn bar(x: root::ns::number) -> ::std::os::raw::c_int; + } + extern "C" { + #[link_name = "\u{1}_ZN2ns3bazENS_5PointE"] + pub fn baz(point: root::ns::Point) -> ::std::os::raw::c_int; + } + } + #[allow(unused_imports)] + use self::super::root; + extern "C" { + #[link_name = "\u{1}_Z3foov"] + pub fn foo() -> ::std::os::raw::c_int; + } + extern "C" { + #[link_name = "\u{1}_Z3bari"] + pub fn bar(x: root::number) -> ::std::os::raw::c_int; + } + extern "C" { + #[link_name = "\u{1}_Z3baz5Point"] + pub fn baz(point: root::Point) -> ::std::os::raw::c_int; + } +} diff --git a/bindgen-tests/tests/expectations/tests/sorted_items.rs b/bindgen-tests/tests/expectations/tests/sorted_items.rs new file mode 100644 index 0000000000..1c235fb31d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/sorted_items.rs @@ -0,0 +1,90 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + pub type number = ::std::os::raw::c_int; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Point { + pub x: root::number, + pub y: root::number, + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Angle { + pub a: root::number, + pub b: root::number, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Point"][::std::mem::size_of::() - 8usize]; + ["Alignment of Point"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Point::x"][::std::mem::offset_of!(Point, x) - 0usize]; + ["Offset of field: Point::y"][::std::mem::offset_of!(Point, y) - 4usize]; + }; + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Angle"][::std::mem::size_of::() - 8usize]; + ["Alignment of Angle"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Angle::a"][::std::mem::offset_of!(Angle, a) - 0usize]; + ["Offset of field: Angle::b"][::std::mem::offset_of!(Angle, b) - 4usize]; + }; + pub const NUMBER: root::number = 42; + pub mod ns { + pub type number = ::std::os::raw::c_int; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Point { + pub x: root::ns::number, + pub y: root::ns::number, + } + #[repr(C)] + #[derive(Debug, Default, Copy, Clone)] + pub struct Angle { + pub a: root::ns::number, + pub b: root::ns::number, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Point"][::std::mem::size_of::() - 8usize]; + ["Alignment of Point"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Point::x"][::std::mem::offset_of!(Point, x) - 0usize]; + ["Offset of field: Point::y"][::std::mem::offset_of!(Point, y) - 4usize]; + }; + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of Angle"][::std::mem::size_of::() - 8usize]; + ["Alignment of Angle"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Angle::a"][::std::mem::offset_of!(Angle, a) - 0usize]; + ["Offset of field: Angle::b"][::std::mem::offset_of!(Angle, b) - 4usize]; + }; + pub const NUMBER: root::ns::number = 42; + #[allow(unused_imports)] + use self::super::super::root; + unsafe extern "C" { + #[link_name = "\u{1}_ZN2ns3fooEv"] + pub fn foo() -> ::std::os::raw::c_int; + } + unsafe extern "C" { + #[link_name = "\u{1}_ZN2ns3barEi"] + pub fn bar(x: root::ns::number) -> ::std::os::raw::c_int; + } + unsafe extern "C" { + #[link_name = "\u{1}_ZN2ns3bazENS_5PointE"] + pub fn baz(point: root::ns::Point) -> ::std::os::raw::c_int; + } + } + #[allow(unused_imports)] + use self::super::root; + unsafe extern "C" { + #[link_name = "\u{1}_Z3foov"] + pub fn foo() -> ::std::os::raw::c_int; + } + unsafe extern "C" { + #[link_name = "\u{1}_Z3bari"] + pub fn bar(x: root::number) -> ::std::os::raw::c_int; + } + unsafe extern "C" { + #[link_name = "\u{1}_Z3baz5Point"] + pub fn baz(point: root::Point) -> ::std::os::raw::c_int; + } +} diff --git a/bindgen-tests/tests/expectations/tests/special-members.rs b/bindgen-tests/tests/expectations/tests/special-members.rs new file mode 100644 index 0000000000..4f54670c86 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/special-members.rs @@ -0,0 +1,51 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default)] +pub struct A { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of A"][::std::mem::size_of::() - 1usize]; + ["Alignment of A"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN1AC1Ev"] + pub fn A_A(this: *mut A); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN1AC1ERS_"] + pub fn A_A1(this: *mut A, arg1: *mut A); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN1AC1EOS_"] + pub fn A_A2(this: *mut A, arg1: *mut A); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN1AD1Ev"] + pub fn A_A_destructor(this: *mut A); +} +impl A { + #[inline] + pub unsafe fn new() -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + A_A(__bindgen_tmp.as_mut_ptr()); + __bindgen_tmp.assume_init() + } + #[inline] + pub unsafe fn new1(arg1: *mut A) -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + A_A1(__bindgen_tmp.as_mut_ptr(), arg1); + __bindgen_tmp.assume_init() + } + #[inline] + pub unsafe fn new2(arg1: *mut A) -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + A_A2(__bindgen_tmp.as_mut_ptr(), arg1); + __bindgen_tmp.assume_init() + } + #[inline] + pub unsafe fn destruct(&mut self) { + A_A_destructor(self) + } +} diff --git a/bindgen-tests/tests/expectations/tests/specific_receiver.rs b/bindgen-tests/tests/expectations/tests/specific_receiver.rs new file mode 100644 index 0000000000..ec001b12ad --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/specific_receiver.rs @@ -0,0 +1,28 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct Fish__bindgen_vtable { + pub Fish_swim: unsafe extern "C" fn(this: *mut Fish), +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fish { + pub vtable_: *const Fish__bindgen_vtable, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Fish"][::std::mem::size_of::() - 8usize]; + ["Alignment of Fish"][::std::mem::align_of::() - 8usize]; +}; +impl Default for Fish { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN4Fish4swimEv"] + pub fn Fish_swim(this: *mut Fish); +} diff --git a/bindgen-tests/tests/expectations/tests/stdint_typedef.rs b/bindgen-tests/tests/expectations/tests/stdint_typedef.rs new file mode 100644 index 0000000000..7cb1a2a8fb --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/stdint_typedef.rs @@ -0,0 +1,15 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn fun() -> u64; +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Struct { + pub field: u64, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Struct"][::std::mem::size_of::() - 8usize]; + ["Alignment of Struct"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Struct::field"][::std::mem::offset_of!(Struct, field) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/strings_array.rs b/bindgen-tests/tests/expectations/tests/strings_array.rs new file mode 100644 index 0000000000..12543e59a8 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/strings_array.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const MY_STRING_UTF8: &[u8; 14] = b"Hello, world!\0"; +pub const MY_STRING_INTERIOR_NULL: &[u8; 7] = b"Hello,\0"; +pub const MY_STRING_NON_UTF8: &[u8; 7] = b"ABCDE\xFF\0"; diff --git a/bindgen-tests/tests/expectations/tests/strings_cstr.rs b/bindgen-tests/tests/expectations/tests/strings_cstr.rs new file mode 100644 index 0000000000..ca089cf130 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/strings_cstr.rs @@ -0,0 +1,13 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(unsafe_code)] +pub const MY_STRING_UTF8: &::std::ffi::CStr = unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"Hello, world!\0") +}; +#[allow(unsafe_code)] +pub const MY_STRING_INTERIOR_NULL: &::std::ffi::CStr = unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"Hello,\0") +}; +#[allow(unsafe_code)] +pub const MY_STRING_NON_UTF8: &::std::ffi::CStr = unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"ABCDE\xFF\0") +}; diff --git a/bindgen-tests/tests/expectations/tests/strings_cstr2.rs b/bindgen-tests/tests/expectations/tests/strings_cstr2.rs new file mode 100644 index 0000000000..2ce21f4374 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/strings_cstr2.rs @@ -0,0 +1,4 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const MY_STRING_UTF8: &::std::ffi::CStr = c"Hello, world!"; +pub const MY_STRING_INTERIOR_NULL: &::std::ffi::CStr = c"Hello,"; +pub const MY_STRING_NON_UTF8: &::std::ffi::CStr = c"ABCDE\xFF"; diff --git a/bindgen-tests/tests/expectations/tests/strings_cstr2_2018.rs b/bindgen-tests/tests/expectations/tests/strings_cstr2_2018.rs new file mode 100644 index 0000000000..ca089cf130 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/strings_cstr2_2018.rs @@ -0,0 +1,13 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(unsafe_code)] +pub const MY_STRING_UTF8: &::std::ffi::CStr = unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"Hello, world!\0") +}; +#[allow(unsafe_code)] +pub const MY_STRING_INTERIOR_NULL: &::std::ffi::CStr = unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"Hello,\0") +}; +#[allow(unsafe_code)] +pub const MY_STRING_NON_UTF8: &::std::ffi::CStr = unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"ABCDE\xFF\0") +}; diff --git a/bindgen-tests/tests/expectations/tests/struct_containing_forward_declared_struct.rs b/bindgen-tests/tests/expectations/tests/struct_containing_forward_declared_struct.rs new file mode 100644 index 0000000000..0fe9024a5f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/struct_containing_forward_declared_struct.rs @@ -0,0 +1,32 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct a { + pub val_a: *mut b, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of a"][::std::mem::size_of::() - 8usize]; + ["Alignment of a"][::std::mem::align_of::() - 8usize]; + ["Offset of field: a::val_a"][::std::mem::offset_of!(a, val_a) - 0usize]; +}; +impl Default for a { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct b { + pub val_b: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of b"][::std::mem::size_of::() - 4usize]; + ["Alignment of b"][::std::mem::align_of::() - 4usize]; + ["Offset of field: b::val_b"][::std::mem::offset_of!(b, val_b) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/struct_typedef.rs b/bindgen-tests/tests/expectations/tests/struct_typedef.rs new file mode 100644 index 0000000000..bc12a1bce8 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/struct_typedef.rs @@ -0,0 +1,55 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct typedef_named_struct { + pub has_name: bool, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of typedef_named_struct", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of typedef_named_struct", + ][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: typedef_named_struct::has_name", + ][::std::mem::offset_of!(typedef_named_struct, has_name) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct _bindgen_ty_1 { + pub no_name: *mut ::std::os::raw::c_void, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _bindgen_ty_1"][::std::mem::size_of::<_bindgen_ty_1>() - 8usize]; + ["Alignment of _bindgen_ty_1"][::std::mem::align_of::<_bindgen_ty_1>() - 8usize]; + [ + "Offset of field: _bindgen_ty_1::no_name", + ][::std::mem::offset_of!(_bindgen_ty_1, no_name) - 0usize]; +}; +impl Default for _bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type struct_ptr_t = *mut _bindgen_ty_1; +pub type struct_ptr_ptr_t = *mut *mut _bindgen_ty_1; +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum typedef_named_enum { + ENUM_HAS_NAME = 1, +} +pub const ENUM_IS_ANON: _bindgen_ty_2 = _bindgen_ty_2::ENUM_IS_ANON; +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum _bindgen_ty_2 { + ENUM_IS_ANON = 0, +} +pub type enum_ptr_t = *mut _bindgen_ty_2; +pub type enum_ptr_ptr_t = *mut *mut _bindgen_ty_2; diff --git a/bindgen-tests/tests/expectations/tests/struct_typedef_ns.rs b/bindgen-tests/tests/expectations/tests/struct_typedef_ns.rs new file mode 100644 index 0000000000..82f93dfd16 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/struct_typedef_ns.rs @@ -0,0 +1,54 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod whatever { + #[allow(unused_imports)] + use self::super::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] + pub struct typedef_struct { + pub foo: ::std::os::raw::c_int, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of typedef_struct"][::std::mem::size_of::() - 4usize]; + [ + "Alignment of typedef_struct", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: typedef_struct::foo", + ][::std::mem::offset_of!(typedef_struct, foo) - 0usize]; + }; + #[repr(u32)] + #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] + pub enum typedef_enum { + BAR = 1, + } + } + pub mod _bindgen_mod_id_12 { + #[allow(unused_imports)] + use self::super::super::root; + #[repr(C)] + #[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] + pub struct typedef_struct { + pub foo: ::std::os::raw::c_int, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of typedef_struct"][::std::mem::size_of::() - 4usize]; + [ + "Alignment of typedef_struct", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: typedef_struct::foo", + ][::std::mem::offset_of!(typedef_struct, foo) - 0usize]; + }; + #[repr(u32)] + #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] + pub enum typedef_enum { + BAR = 1, + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/struct_with_anon_struct.rs b/bindgen-tests/tests/expectations/tests/struct_with_anon_struct.rs new file mode 100644 index 0000000000..51aa19c572 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/struct_with_anon_struct.rs @@ -0,0 +1,31 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct foo { + pub bar: foo__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct foo__bindgen_ty_1 { + pub a: ::std::os::raw::c_int, + pub b: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo__bindgen_ty_1"][::std::mem::size_of::() - 8usize]; + [ + "Alignment of foo__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: foo__bindgen_ty_1::a", + ][::std::mem::offset_of!(foo__bindgen_ty_1, a) - 0usize]; + [ + "Offset of field: foo__bindgen_ty_1::b", + ][::std::mem::offset_of!(foo__bindgen_ty_1, b) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 8usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::bar"][::std::mem::offset_of!(foo, bar) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/struct_with_anon_struct_array.rs b/bindgen-tests/tests/expectations/tests/struct_with_anon_struct_array.rs new file mode 100644 index 0000000000..930e6b9aba --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/struct_with_anon_struct_array.rs @@ -0,0 +1,52 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct foo { + pub bar: [foo__bindgen_ty_1; 2usize], + pub baz: [[[foo__bindgen_ty_2; 4usize]; 3usize]; 2usize], +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct foo__bindgen_ty_1 { + pub a: ::std::os::raw::c_int, + pub b: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo__bindgen_ty_1"][::std::mem::size_of::() - 8usize]; + [ + "Alignment of foo__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: foo__bindgen_ty_1::a", + ][::std::mem::offset_of!(foo__bindgen_ty_1, a) - 0usize]; + [ + "Offset of field: foo__bindgen_ty_1::b", + ][::std::mem::offset_of!(foo__bindgen_ty_1, b) - 4usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct foo__bindgen_ty_2 { + pub a: ::std::os::raw::c_int, + pub b: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo__bindgen_ty_2"][::std::mem::size_of::() - 8usize]; + [ + "Alignment of foo__bindgen_ty_2", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: foo__bindgen_ty_2::a", + ][::std::mem::offset_of!(foo__bindgen_ty_2, a) - 0usize]; + [ + "Offset of field: foo__bindgen_ty_2::b", + ][::std::mem::offset_of!(foo__bindgen_ty_2, b) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 208usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::bar"][::std::mem::offset_of!(foo, bar) - 0usize]; + ["Offset of field: foo::baz"][::std::mem::offset_of!(foo, baz) - 16usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/struct_with_anon_struct_pointer.rs b/bindgen-tests/tests/expectations/tests/struct_with_anon_struct_pointer.rs new file mode 100644 index 0000000000..6bdee34590 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/struct_with_anon_struct_pointer.rs @@ -0,0 +1,40 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct foo { + pub bar: *mut foo__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct foo__bindgen_ty_1 { + pub a: ::std::os::raw::c_int, + pub b: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo__bindgen_ty_1"][::std::mem::size_of::() - 8usize]; + [ + "Alignment of foo__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: foo__bindgen_ty_1::a", + ][::std::mem::offset_of!(foo__bindgen_ty_1, a) - 0usize]; + [ + "Offset of field: foo__bindgen_ty_1::b", + ][::std::mem::offset_of!(foo__bindgen_ty_1, b) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 8usize]; + ["Alignment of foo"][::std::mem::align_of::() - 8usize]; + ["Offset of field: foo::bar"][::std::mem::offset_of!(foo, bar) - 0usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/struct_with_anon_union.rs b/bindgen-tests/tests/expectations/tests/struct_with_anon_union.rs new file mode 100644 index 0000000000..6520163259 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/struct_with_anon_union.rs @@ -0,0 +1,49 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct foo { + pub bar: foo__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union foo__bindgen_ty_1 { + pub a: ::std::os::raw::c_uint, + pub b: ::std::os::raw::c_ushort, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo__bindgen_ty_1"][::std::mem::size_of::() - 4usize]; + [ + "Alignment of foo__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: foo__bindgen_ty_1::a", + ][::std::mem::offset_of!(foo__bindgen_ty_1, a) - 0usize]; + [ + "Offset of field: foo__bindgen_ty_1::b", + ][::std::mem::offset_of!(foo__bindgen_ty_1, b) - 0usize]; +}; +impl Default for foo__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::bar"][::std::mem::offset_of!(foo, bar) - 0usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/struct_with_anon_unnamed_struct.rs b/bindgen-tests/tests/expectations/tests/struct_with_anon_unnamed_struct.rs new file mode 100644 index 0000000000..29cf382e5f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/struct_with_anon_unnamed_struct.rs @@ -0,0 +1,30 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct foo { + pub __bindgen_anon_1: foo__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct foo__bindgen_ty_1 { + pub a: ::std::os::raw::c_uint, + pub b: ::std::os::raw::c_uint, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo__bindgen_ty_1"][::std::mem::size_of::() - 8usize]; + [ + "Alignment of foo__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: foo__bindgen_ty_1::a", + ][::std::mem::offset_of!(foo__bindgen_ty_1, a) - 0usize]; + [ + "Offset of field: foo__bindgen_ty_1::b", + ][::std::mem::offset_of!(foo__bindgen_ty_1, b) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 8usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/struct_with_anon_unnamed_union.rs b/bindgen-tests/tests/expectations/tests/struct_with_anon_unnamed_union.rs new file mode 100644 index 0000000000..2f95e0f5e0 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/struct_with_anon_unnamed_union.rs @@ -0,0 +1,48 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct foo { + pub __bindgen_anon_1: foo__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union foo__bindgen_ty_1 { + pub a: ::std::os::raw::c_uint, + pub b: ::std::os::raw::c_ushort, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo__bindgen_ty_1"][::std::mem::size_of::() - 4usize]; + [ + "Alignment of foo__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: foo__bindgen_ty_1::a", + ][::std::mem::offset_of!(foo__bindgen_ty_1, a) - 0usize]; + [ + "Offset of field: foo__bindgen_ty_1::b", + ][::std::mem::offset_of!(foo__bindgen_ty_1, b) - 0usize]; +}; +impl Default for foo__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/struct_with_bitfields.rs b/bindgen-tests/tests/expectations/tests/struct_with_bitfields.rs new file mode 100644 index 0000000000..a294c871d3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/struct_with_bitfields.rs @@ -0,0 +1,450 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct bitfield { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub e: ::std::os::raw::c_int, + pub _bitfield_2: __BindgenBitfieldUnit<[u8; 8usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of bitfield"][::std::mem::size_of::() - 16usize]; + ["Alignment of bitfield"][::std::mem::align_of::() - 4usize]; + ["Offset of field: bitfield::e"][::std::mem::offset_of!(bitfield, e) - 4usize]; +}; +impl bitfield { + #[inline] + pub fn a(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) } + } + #[inline] + pub fn set_a(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn a_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_a_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn b(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16) } + } + #[inline] + pub fn set_b(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn b_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_b_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn c(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16) } + } + #[inline] + pub fn set_c(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn c_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_c_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn d(&self) -> ::std::os::raw::c_ushort { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u16) } + } + #[inline] + pub fn set_d(&mut self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn d_raw(this: *const Self) -> ::std::os::raw::c_ushort { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 6usize, 2u8) + as u16, + ) + } + } + #[inline] + pub unsafe fn set_d_raw(this: *mut Self, val: ::std::os::raw::c_ushort) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + a: ::std::os::raw::c_ushort, + b: ::std::os::raw::c_ushort, + c: ::std::os::raw::c_ushort, + d: ::std::os::raw::c_ushort, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let a: u16 = unsafe { ::std::mem::transmute(a) }; + a as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 1u8, + { + let b: u16 = unsafe { ::std::mem::transmute(b) }; + b as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 2usize, + 1u8, + { + let c: u16 = unsafe { ::std::mem::transmute(c) }; + c as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 6usize, + 2u8, + { + let d: u16 = unsafe { ::std::mem::transmute(d) }; + d as u64 + }, + ); + __bindgen_bitfield_unit + } + #[inline] + pub fn f(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 2u8) as u32) } + } + #[inline] + pub fn set_f(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_2.set(0usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn f_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 8usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_2), 0usize, 2u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_f_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 8usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 0usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn g(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_2.get(32usize, 32u8) as u32) } + } + #[inline] + pub fn set_g(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_2.set(32usize, 32u8, val as u64) + } + } + #[inline] + pub unsafe fn g_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 8usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_2), 32usize, 32u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_g_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 8usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 32usize, + 32u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_2( + f: ::std::os::raw::c_uint, + g: ::std::os::raw::c_uint, + ) -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 2u8, + { + let f: u32 = unsafe { ::std::mem::transmute(f) }; + f as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 32usize, + 32u8, + { + let g: u32 = unsafe { ::std::mem::transmute(g) }; + g as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/struct_with_derive_debug.rs b/bindgen-tests/tests/expectations/tests/struct_with_derive_debug.rs new file mode 100644 index 0000000000..f86fe6fb8f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/struct_with_derive_debug.rs @@ -0,0 +1,67 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct LittleArray { + pub a: [::std::os::raw::c_int; 32usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of LittleArray"][::std::mem::size_of::() - 128usize]; + ["Alignment of LittleArray"][::std::mem::align_of::() - 4usize]; + ["Offset of field: LittleArray::a"][::std::mem::offset_of!(LittleArray, a) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct BigArray { + pub a: [::std::os::raw::c_int; 33usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of BigArray"][::std::mem::size_of::() - 132usize]; + ["Alignment of BigArray"][::std::mem::align_of::() - 4usize]; + ["Offset of field: BigArray::a"][::std::mem::offset_of!(BigArray, a) - 0usize]; +}; +impl Default for BigArray { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct WithLittleArray { + pub a: LittleArray, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of WithLittleArray"][::std::mem::size_of::() - 128usize]; + ["Alignment of WithLittleArray"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: WithLittleArray::a", + ][::std::mem::offset_of!(WithLittleArray, a) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct WithBigArray { + pub a: BigArray, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of WithBigArray"][::std::mem::size_of::() - 132usize]; + ["Alignment of WithBigArray"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: WithBigArray::a", + ][::std::mem::offset_of!(WithBigArray, a) - 0usize]; +}; +impl Default for WithBigArray { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/struct_with_large_array.rs b/bindgen-tests/tests/expectations/tests/struct_with_large_array.rs new file mode 100644 index 0000000000..df7a2192ed --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/struct_with_large_array.rs @@ -0,0 +1,36 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct S { + pub large_array: [::std::os::raw::c_char; 33usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of S"][::std::mem::size_of::() - 33usize]; + ["Alignment of S"][::std::mem::align_of::() - 1usize]; + ["Offset of field: S::large_array"][::std::mem::offset_of!(S, large_array) - 0usize]; +}; +impl Default for S { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Hash, PartialEq, Eq)] +pub struct ST { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub large_array: [T; 33usize], +} +impl Default for ST { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/struct_with_nesting.rs b/bindgen-tests/tests/expectations/tests/struct_with_nesting.rs new file mode 100644 index 0000000000..369384e88c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/struct_with_nesting.rs @@ -0,0 +1,98 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct foo { + pub a: ::std::os::raw::c_uint, + pub __bindgen_anon_1: foo__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union foo__bindgen_ty_1 { + pub b: ::std::os::raw::c_uint, + pub __bindgen_anon_1: foo__bindgen_ty_1__bindgen_ty_1, + pub __bindgen_anon_2: foo__bindgen_ty_1__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct foo__bindgen_ty_1__bindgen_ty_1 { + pub c1: ::std::os::raw::c_ushort, + pub c2: ::std::os::raw::c_ushort, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of foo__bindgen_ty_1__bindgen_ty_1", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of foo__bindgen_ty_1__bindgen_ty_1", + ][::std::mem::align_of::() - 2usize]; + [ + "Offset of field: foo__bindgen_ty_1__bindgen_ty_1::c1", + ][::std::mem::offset_of!(foo__bindgen_ty_1__bindgen_ty_1, c1) - 0usize]; + [ + "Offset of field: foo__bindgen_ty_1__bindgen_ty_1::c2", + ][::std::mem::offset_of!(foo__bindgen_ty_1__bindgen_ty_1, c2) - 2usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct foo__bindgen_ty_1__bindgen_ty_2 { + pub d1: ::std::os::raw::c_uchar, + pub d2: ::std::os::raw::c_uchar, + pub d3: ::std::os::raw::c_uchar, + pub d4: ::std::os::raw::c_uchar, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of foo__bindgen_ty_1__bindgen_ty_2", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of foo__bindgen_ty_1__bindgen_ty_2", + ][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: foo__bindgen_ty_1__bindgen_ty_2::d1", + ][::std::mem::offset_of!(foo__bindgen_ty_1__bindgen_ty_2, d1) - 0usize]; + [ + "Offset of field: foo__bindgen_ty_1__bindgen_ty_2::d2", + ][::std::mem::offset_of!(foo__bindgen_ty_1__bindgen_ty_2, d2) - 1usize]; + [ + "Offset of field: foo__bindgen_ty_1__bindgen_ty_2::d3", + ][::std::mem::offset_of!(foo__bindgen_ty_1__bindgen_ty_2, d3) - 2usize]; + [ + "Offset of field: foo__bindgen_ty_1__bindgen_ty_2::d4", + ][::std::mem::offset_of!(foo__bindgen_ty_1__bindgen_ty_2, d4) - 3usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo__bindgen_ty_1"][::std::mem::size_of::() - 4usize]; + [ + "Alignment of foo__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: foo__bindgen_ty_1::b", + ][::std::mem::offset_of!(foo__bindgen_ty_1, b) - 0usize]; +}; +impl Default for foo__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 8usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::a"][::std::mem::offset_of!(foo, a) - 0usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/struct_with_packing.rs b/bindgen-tests/tests/expectations/tests/struct_with_packing.rs new file mode 100644 index 0000000000..2687f9750b --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/struct_with_packing.rs @@ -0,0 +1,14 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C, packed)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct a { + pub b: ::std::os::raw::c_char, + pub c: ::std::os::raw::c_short, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of a"][::std::mem::size_of::() - 3usize]; + ["Alignment of a"][::std::mem::align_of::() - 1usize]; + ["Offset of field: a::b"][::std::mem::offset_of!(a, b) - 0usize]; + ["Offset of field: a::c"][::std::mem::offset_of!(a, c) - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/struct_with_struct.rs b/bindgen-tests/tests/expectations/tests/struct_with_struct.rs new file mode 100644 index 0000000000..40c3972600 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/struct_with_struct.rs @@ -0,0 +1,31 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct foo { + pub bar: foo__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct foo__bindgen_ty_1 { + pub x: ::std::os::raw::c_uint, + pub y: ::std::os::raw::c_uint, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo__bindgen_ty_1"][::std::mem::size_of::() - 8usize]; + [ + "Alignment of foo__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: foo__bindgen_ty_1::x", + ][::std::mem::offset_of!(foo__bindgen_ty_1, x) - 0usize]; + [ + "Offset of field: foo__bindgen_ty_1::y", + ][::std::mem::offset_of!(foo__bindgen_ty_1, y) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 8usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::bar"][::std::mem::offset_of!(foo, bar) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/struct_with_typedef_template_arg.rs b/bindgen-tests/tests/expectations/tests/struct_with_typedef_template_arg.rs new file mode 100644 index 0000000000..2aaae12dcf --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/struct_with_typedef_template_arg.rs @@ -0,0 +1,7 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Proxy { + pub _address: u8, +} +pub type Proxy_foo = ::std::option::Option; diff --git a/bindgen-tests/tests/expectations/tests/template-fun-ty.rs b/bindgen-tests/tests/expectations/tests/template-fun-ty.rs new file mode 100644 index 0000000000..5337af037a --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template-fun-ty.rs @@ -0,0 +1,21 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Foo { + pub _address: u8, +} +pub type Foo_FunctionPtr = ::std::option::Option T>; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct RefPtr { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct RefPtr_Proxy { + pub _address: u8, +} +pub type RefPtr_Proxy_member_function = ::std::option::Option< + unsafe extern "C" fn(arg1: Args) -> R, +>; +pub type Returner = ::std::option::Option T>; diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-0.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-0.rs new file mode 100644 index 0000000000..ba8980be00 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template-param-usage-0.rs @@ -0,0 +1,16 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct UsesTemplateParameter { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub t: T, +} +impl Default for UsesTemplateParameter { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-1.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-1.rs new file mode 100644 index 0000000000..7cbec9610d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template-param-usage-1.rs @@ -0,0 +1,6 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct DoesNotUseTemplateParameter { + pub x: ::std::os::raw::c_int, +} diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-10.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-10.rs new file mode 100644 index 0000000000..a4e5d0ce82 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template-param-usage-10.rs @@ -0,0 +1,36 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct DoublyIndirectUsage { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub doubly_indirect: DoublyIndirectUsage_IndirectUsage, +} +pub type DoublyIndirectUsage_Aliased = T; +pub type DoublyIndirectUsage_Typedefed = U; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct DoublyIndirectUsage_IndirectUsage { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub member: DoublyIndirectUsage_Aliased, + pub another: DoublyIndirectUsage_Typedefed, +} +impl Default for DoublyIndirectUsage_IndirectUsage { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Default for DoublyIndirectUsage { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-11.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-11.rs new file mode 100644 index 0000000000..e914375875 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template-param-usage-11.rs @@ -0,0 +1,6 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct DoesNotUseT { + pub _address: u8, +} diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-12.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-12.rs new file mode 100644 index 0000000000..7f3a306b6b --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template-param-usage-12.rs @@ -0,0 +1,32 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct BaseUsesT { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub t: *mut T, +} +impl Default for BaseUsesT { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct CrtpUsesU { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub _base: BaseUsesT>, + pub usage: U, +} +impl Default for CrtpUsesU { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-13.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-13.rs new file mode 100644 index 0000000000..185f16be11 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template-param-usage-13.rs @@ -0,0 +1,22 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct BaseIgnoresT { + pub x: ::std::os::raw::c_int, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct CrtpUsesU { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub _base: BaseIgnoresT, + pub usage: U, +} +impl Default for CrtpUsesU { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-14.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-14.rs new file mode 100644 index 0000000000..b008bb5b8f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template-param-usage-14.rs @@ -0,0 +1,21 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct BaseIgnoresT { + pub x: ::std::os::raw::c_int, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct CrtpIgnoresU { + pub _base: BaseIgnoresT, + pub y: ::std::os::raw::c_int, +} +impl Default for CrtpIgnoresU { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-15.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-15.rs new file mode 100644 index 0000000000..fced6dc58c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template-param-usage-15.rs @@ -0,0 +1,31 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct BaseUsesT { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub usage: *mut T, +} +impl Default for BaseUsesT { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct CrtpIgnoresU { + pub _base: BaseUsesT, + pub y: ::std::os::raw::c_int, +} +impl Default for CrtpIgnoresU { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-2.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-2.rs new file mode 100644 index 0000000000..4c671ce2ab --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template-param-usage-2.rs @@ -0,0 +1,31 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct UsesTemplateParameter { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub t: T, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct UsesTemplateParameter_AlsoUsesTemplateParameter { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub also: T, +} +impl Default for UsesTemplateParameter_AlsoUsesTemplateParameter { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Default for UsesTemplateParameter { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-3.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-3.rs new file mode 100644 index 0000000000..511365e656 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template-param-usage-3.rs @@ -0,0 +1,33 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct UsesTemplateParameter { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub t: T, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct UsesTemplateParameter_AlsoUsesTemplateParameterAndMore { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub also: T, + pub more: U, +} +impl Default for UsesTemplateParameter_AlsoUsesTemplateParameterAndMore { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Default for UsesTemplateParameter { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-4.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-4.rs new file mode 100644 index 0000000000..5655a6d260 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template-param-usage-4.rs @@ -0,0 +1,21 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct UsesTemplateParameter { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub t: T, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct UsesTemplateParameter_DoesNotUseTemplateParameters { + pub x: ::std::os::raw::c_int, +} +impl Default for UsesTemplateParameter { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-5.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-5.rs new file mode 100644 index 0000000000..5049559b33 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template-param-usage-5.rs @@ -0,0 +1,17 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct IndirectlyUsesTemplateParameter { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub aliased: IndirectlyUsesTemplateParameter_Aliased, +} +pub type IndirectlyUsesTemplateParameter_Aliased = T; +impl Default for IndirectlyUsesTemplateParameter { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-6.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-6.rs new file mode 100644 index 0000000000..0a08bc9da9 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template-param-usage-6.rs @@ -0,0 +1,7 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct DoesNotUseTemplateParameter { + pub x: ::std::os::raw::c_int, +} +pub type DoesNotUseTemplateParameter_ButAliasDoesUseIt = T; diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-7.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-7.rs new file mode 100644 index 0000000000..1552ae852f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template-param-usage-7.rs @@ -0,0 +1,19 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct DoesNotUseU { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub t: T, + pub v: V, +} +impl Default for DoesNotUseU { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type Alias = DoesNotUseU<::std::os::raw::c_int, ::std::os::raw::c_char>; diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-8.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-8.rs new file mode 100644 index 0000000000..61de18a833 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template-param-usage-8.rs @@ -0,0 +1,20 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct IndirectUsage { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub member1: IndirectUsage_Typedefed, + pub member2: IndirectUsage_Aliased, +} +pub type IndirectUsage_Typedefed = T; +pub type IndirectUsage_Aliased = U; +impl Default for IndirectUsage { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-9.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-9.rs new file mode 100644 index 0000000000..ff0eedc8ae --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template-param-usage-9.rs @@ -0,0 +1,25 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct DoesNotUse { + pub _address: u8, +} +pub type DoesNotUse_Aliased = T; +pub type DoesNotUse_Typedefed = U; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct DoesNotUse_IndirectUsage { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub member: DoesNotUse_Aliased, + pub another: DoesNotUse_Typedefed, +} +impl Default for DoesNotUse_IndirectUsage { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/template-with-var.rs b/bindgen-tests/tests/expectations/tests/template-with-var.rs new file mode 100644 index 0000000000..cdc0b5b149 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template-with-var.rs @@ -0,0 +1,6 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct TemplateWithVar { + pub _address: u8, +} diff --git a/bindgen-tests/tests/expectations/tests/template.rs b/bindgen-tests/tests/expectations/tests/template.rs new file mode 100644 index 0000000000..94678cb49e --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template.rs @@ -0,0 +1,566 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Hash, PartialEq, Eq)] +pub struct Foo { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub m_member: T, + pub m_member_ptr: *mut T, + pub m_member_arr: [T; 1usize], +} +impl Default for Foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct B { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub m_member: T, +} +impl Default for B { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +unsafe extern "C" { + #[link_name = "\u{1}_Z3bar3FooIiiE"] + pub fn bar(foo: Foo<::std::os::raw::c_int>); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct mozilla_Foo { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct C { + pub mB: B<::std::os::raw::c_uint>, + pub mBConstPtr: B<*const ::std::os::raw::c_int>, + pub mBConstStructPtr: B<*const mozilla_Foo>, + pub mBConstStructPtrArray: B<[*const mozilla_Foo; 1usize]>, + pub mBConst: B<::std::os::raw::c_int>, + pub mBVolatile: B<::std::os::raw::c_int>, + pub mBConstBool: B, + pub mBConstChar: B, + pub mBArray: B<[::std::os::raw::c_int; 1usize]>, + pub mBPtrArray: B<[*mut ::std::os::raw::c_int; 1usize]>, + pub mBArrayPtr: B<*mut [::std::os::raw::c_int; 1usize]>, + pub mBRef: B<*mut ::std::os::raw::c_int>, + pub mBConstRef: B<*const ::std::os::raw::c_int>, + pub mPtrRef: B<*mut *mut ::std::os::raw::c_int>, + pub mArrayRef: B<*mut [::std::os::raw::c_int; 1usize]>, + pub mBConstArray: B<[::std::os::raw::c_int; 1usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C"][::std::mem::size_of::() - 104usize]; + ["Alignment of C"][::std::mem::align_of::() - 8usize]; + ["Offset of field: C::mB"][::std::mem::offset_of!(C, mB) - 0usize]; + ["Offset of field: C::mBConstPtr"][::std::mem::offset_of!(C, mBConstPtr) - 8usize]; + [ + "Offset of field: C::mBConstStructPtr", + ][::std::mem::offset_of!(C, mBConstStructPtr) - 16usize]; + [ + "Offset of field: C::mBConstStructPtrArray", + ][::std::mem::offset_of!(C, mBConstStructPtrArray) - 24usize]; + ["Offset of field: C::mBConst"][::std::mem::offset_of!(C, mBConst) - 32usize]; + ["Offset of field: C::mBVolatile"][::std::mem::offset_of!(C, mBVolatile) - 36usize]; + [ + "Offset of field: C::mBConstBool", + ][::std::mem::offset_of!(C, mBConstBool) - 40usize]; + [ + "Offset of field: C::mBConstChar", + ][::std::mem::offset_of!(C, mBConstChar) - 42usize]; + ["Offset of field: C::mBArray"][::std::mem::offset_of!(C, mBArray) - 44usize]; + ["Offset of field: C::mBPtrArray"][::std::mem::offset_of!(C, mBPtrArray) - 48usize]; + ["Offset of field: C::mBArrayPtr"][::std::mem::offset_of!(C, mBArrayPtr) - 56usize]; + ["Offset of field: C::mBRef"][::std::mem::offset_of!(C, mBRef) - 64usize]; + ["Offset of field: C::mBConstRef"][::std::mem::offset_of!(C, mBConstRef) - 72usize]; + ["Offset of field: C::mPtrRef"][::std::mem::offset_of!(C, mPtrRef) - 80usize]; + ["Offset of field: C::mArrayRef"][::std::mem::offset_of!(C, mArrayRef) - 88usize]; + [ + "Offset of field: C::mBConstArray", + ][::std::mem::offset_of!(C, mBConstArray) - 96usize]; +}; +impl Default for C { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Hash, PartialEq, Eq)] +pub struct D { + pub m_foo: D_MyFoo, +} +pub type D_MyFoo = Foo<::std::os::raw::c_int>; +#[repr(C)] +#[derive(Debug, Hash, PartialEq, Eq)] +pub struct D_U { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub m_nested_foo: D_MyFoo, + pub m_baz: Z, +} +impl Default for D_U { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Default for D { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Rooted { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub prev: *mut T, + pub next: *mut Rooted<*mut ::std::os::raw::c_void>, + pub ptr: T, +} +impl Default for Rooted { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct RootedContainer { + pub root: Rooted<*mut ::std::os::raw::c_void>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of RootedContainer"][::std::mem::size_of::() - 24usize]; + ["Alignment of RootedContainer"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: RootedContainer::root", + ][::std::mem::offset_of!(RootedContainer, root) - 0usize]; +}; +impl Default for RootedContainer { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type WithDtorIntFwd = WithDtor<::std::os::raw::c_int>; +#[repr(C)] +#[derive(Debug, Hash, PartialEq, Eq)] +pub struct WithDtor { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub member: T, +} +impl Default for WithDtor { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Hash, PartialEq, Eq)] +pub struct PODButContainsDtor { + pub member: WithDtorIntFwd, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of PODButContainsDtor"][::std::mem::size_of::() - 4usize]; + [ + "Alignment of PODButContainsDtor", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: PODButContainsDtor::member", + ][::std::mem::offset_of!(PODButContainsDtor, member) - 0usize]; +}; +impl Default for PODButContainsDtor { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +///
+#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Opaque { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct POD { + pub opaque_member: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of POD"][::std::mem::size_of::() - 4usize]; + ["Alignment of POD"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: POD::opaque_member", + ][::std::mem::offset_of!(POD, opaque_member) - 0usize]; +}; +///
+#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct NestedReplaced { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub buff: *mut T, +} +impl Default for NestedReplaced { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct NestedBase { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub buff: *mut T, +} +impl Default for NestedBase { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct NestedContainer { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub c: T, + pub nested: NestedReplaced, + pub inc: Incomplete, +} +impl Default for NestedContainer { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Incomplete { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub d: T, +} +impl Default for Incomplete { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Untemplated { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Untemplated"][::std::mem::size_of::() - 1usize]; + ["Alignment of Untemplated"][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Templated { + pub m_untemplated: Untemplated, +} +/** If the replacement doesn't happen at the parse level the container would be + copy and the replacement wouldn't, so this wouldn't compile. + +
*/ +#[repr(C)] +#[derive(Debug, Hash, PartialEq, Eq)] +pub struct ReplacedWithoutDestructor { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub buff: *mut T, +} +impl Default for ReplacedWithoutDestructor { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Hash, PartialEq, Eq)] +pub struct ShouldNotBeCopiable { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub m_member: ReplacedWithoutDestructor, +} +impl Default for ShouldNotBeCopiable { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Hash, PartialEq, Eq)] +pub struct ShouldNotBeCopiableAsWell { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub m_member: ReplacedWithoutDestructorFwd, +} +impl Default for ShouldNotBeCopiableAsWell { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +/** If the replacement doesn't happen at the parse level the container would be + copy and the replacement wouldn't, so this wouldn't compile. + +
*/ +#[repr(C)] +#[derive(Debug, Hash, PartialEq, Eq)] +pub struct ReplacedWithoutDestructorFwd { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub buff: *mut T, +} +impl Default for ReplacedWithoutDestructorFwd { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: Foo_open0_int_int_close0", + ][::std::mem::size_of::>() - 24usize]; + [ + "Align of template specialization: Foo_open0_int_int_close0", + ][::std::mem::align_of::>() - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: B_open0_unsigned_int_close0", + ][::std::mem::size_of::>() - 4usize]; + [ + "Align of template specialization: B_open0_unsigned_int_close0", + ][::std::mem::align_of::>() - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: B_open0_ptr_const_int_close0", + ][::std::mem::size_of::>() - 8usize]; + [ + "Align of template specialization: B_open0_ptr_const_int_close0", + ][::std::mem::align_of::>() - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: B_open0_ptr_const_mozilla__Foo_close0", + ][::std::mem::size_of::>() - 8usize]; + [ + "Align of template specialization: B_open0_ptr_const_mozilla__Foo_close0", + ][::std::mem::align_of::>() - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: B_open0_array1_ptr_const_mozilla__Foo_close0", + ][::std::mem::size_of::>() - 8usize]; + [ + "Align of template specialization: B_open0_array1_ptr_const_mozilla__Foo_close0", + ][::std::mem::align_of::>() - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: B_open0_const_int_close0", + ][::std::mem::size_of::>() - 4usize]; + [ + "Align of template specialization: B_open0_const_int_close0", + ][::std::mem::align_of::>() - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: B_open0_volatile_int_close0", + ][::std::mem::size_of::>() - 4usize]; + [ + "Align of template specialization: B_open0_volatile_int_close0", + ][::std::mem::align_of::>() - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: B_open0_const_bool_close0", + ][::std::mem::size_of::>() - 1usize]; + [ + "Align of template specialization: B_open0_const_bool_close0", + ][::std::mem::align_of::>() - 1usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: B_open0_const_char16_t_close0", + ][::std::mem::size_of::>() - 2usize]; + [ + "Align of template specialization: B_open0_const_char16_t_close0", + ][::std::mem::align_of::>() - 2usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: B_open0_array1_int_close0", + ][::std::mem::size_of::>() - 4usize]; + [ + "Align of template specialization: B_open0_array1_int_close0", + ][::std::mem::align_of::>() - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: B_open0_array1_ptr_int_close0", + ][::std::mem::size_of::>() - 8usize]; + [ + "Align of template specialization: B_open0_array1_ptr_int_close0", + ][::std::mem::align_of::>() - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: B_open0_ptr_array1_int_close0", + ][::std::mem::size_of::>() - 8usize]; + [ + "Align of template specialization: B_open0_ptr_array1_int_close0", + ][::std::mem::align_of::>() - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: B_open0_ref_int_close0", + ][::std::mem::size_of::>() - 8usize]; + [ + "Align of template specialization: B_open0_ref_int_close0", + ][::std::mem::align_of::>() - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: B_open0_ref_const_int_close0", + ][::std::mem::size_of::>() - 8usize]; + [ + "Align of template specialization: B_open0_ref_const_int_close0", + ][::std::mem::align_of::>() - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: B_open0_ref_ptr_int_close0", + ][::std::mem::size_of::>() - 8usize]; + [ + "Align of template specialization: B_open0_ref_ptr_int_close0", + ][::std::mem::align_of::>() - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: B_open0_ref_array1_int_close0", + ][::std::mem::size_of::>() - 8usize]; + [ + "Align of template specialization: B_open0_ref_array1_int_close0", + ][::std::mem::align_of::>() - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: B_open0_array1_const_int_close0", + ][::std::mem::size_of::>() - 4usize]; + [ + "Align of template specialization: B_open0_array1_const_int_close0", + ][::std::mem::align_of::>() - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: Foo_open0_int_int_close0", + ][::std::mem::size_of::>() - 24usize]; + [ + "Align of template specialization: Foo_open0_int_int_close0", + ][::std::mem::align_of::>() - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: Rooted_open0_ptr_void_close0", + ][::std::mem::size_of::>() - 24usize]; + [ + "Align of template specialization: Rooted_open0_ptr_void_close0", + ][::std::mem::align_of::>() - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: Rooted_open0_ptr_void_close0", + ][::std::mem::size_of::>() - 24usize]; + [ + "Align of template specialization: Rooted_open0_ptr_void_close0", + ][::std::mem::align_of::>() - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: WithDtor_open0_int_close0", + ][::std::mem::size_of::>() - 4usize]; + [ + "Align of template specialization: WithDtor_open0_int_close0", + ][::std::mem::align_of::>() - 4usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/template_alias.rs b/bindgen-tests/tests/expectations/tests/template_alias.rs new file mode 100644 index 0000000000..b270c9f3a4 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template_alias.rs @@ -0,0 +1,17 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type JS_detail_Wrapped = T; +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct JS_Rooted { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub ptr: JS_detail_Wrapped, +} +impl Default for JS_Rooted { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/template_alias_basic.rs b/bindgen-tests/tests/expectations/tests/template_alias_basic.rs new file mode 100644 index 0000000000..d0f8f104c7 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template_alias_basic.rs @@ -0,0 +1,2 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type Wrapped = T; diff --git a/bindgen-tests/tests/expectations/tests/template_alias_namespace.rs b/bindgen-tests/tests/expectations/tests/template_alias_namespace.rs new file mode 100644 index 0000000000..0aa5fc679a --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template_alias_namespace.rs @@ -0,0 +1,30 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + pub mod JS { + #[allow(unused_imports)] + use self::super::super::root; + pub mod detail { + #[allow(unused_imports)] + use self::super::super::super::root; + pub type Wrapped = T; + } + #[repr(C)] + #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] + pub struct Rooted { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub ptr: root::JS::detail::Wrapped, + } + impl Default for Rooted { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/template_fun.rs b/bindgen-tests/tests/expectations/tests/template_fun.rs new file mode 100644 index 0000000000..fe64295a68 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template_fun.rs @@ -0,0 +1 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] \ No newline at end of file diff --git a/bindgen-tests/tests/expectations/tests/template_instantiation_with_fn_local_type.rs b/bindgen-tests/tests/expectations/tests/template_instantiation_with_fn_local_type.rs new file mode 100644 index 0000000000..085278e603 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template_instantiation_with_fn_local_type.rs @@ -0,0 +1,58 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +unsafe extern "C" { + #[link_name = "\u{1}_Z1fv"] + pub fn f(); +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: Foo_open0_Bar_close0", + ][::std::mem::size_of::() - 1usize]; + [ + "Align of template specialization: Foo_open0_Bar_close0", + ][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Baz { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Baz"][::std::mem::size_of::() - 1usize]; + ["Alignment of Baz"][::std::mem::align_of::() - 1usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: Foo_open0_Boo_close0", + ][::std::mem::size_of::() - 1usize]; + [ + "Align of template specialization: Foo_open0_Boo_close0", + ][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Bar { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 1usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Boo { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Boo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Boo"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/template_partial_specification.rs b/bindgen-tests/tests/expectations/tests/template_partial_specification.rs new file mode 100644 index 0000000000..fe64295a68 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template_partial_specification.rs @@ -0,0 +1 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] \ No newline at end of file diff --git a/bindgen-tests/tests/expectations/tests/template_typedef_transitive_param.rs b/bindgen-tests/tests/expectations/tests/template_typedef_transitive_param.rs new file mode 100644 index 0000000000..2efdde944e --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template_typedef_transitive_param.rs @@ -0,0 +1,22 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Wrapper { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Wrapper_Wrapped { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub t: T, +} +impl Default for Wrapper_Wrapped { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type Wrapper_Type = Wrapper_Wrapped; diff --git a/bindgen-tests/tests/expectations/tests/template_typedefs.rs b/bindgen-tests/tests/expectations/tests/template_typedefs.rs new file mode 100644 index 0000000000..71f0732a63 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/template_typedefs.rs @@ -0,0 +1,12 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type foo = ::std::option::Option; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +pub type Foo_Char = T; +pub type Foo_FooPtrTypedef = *mut Foo_Char; +pub type Foo_nsCOMArrayEnumFunc = ::std::option::Option< + unsafe extern "C" fn(aElement: *mut T, aData: *mut ::std::os::raw::c_void) -> bool, +>; diff --git a/bindgen-tests/tests/expectations/tests/templateref_opaque.rs b/bindgen-tests/tests/expectations/tests/templateref_opaque.rs new file mode 100644 index 0000000000..8f73e86c31 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/templateref_opaque.rs @@ -0,0 +1,13 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct detail_PointerType { + pub _address: u8, +} +pub type detail_PointerType_Type = *mut T; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct UniquePtr { + pub _address: u8, +} +pub type UniquePtr_Pointer = detail_PointerType; diff --git a/bindgen-tests/tests/expectations/tests/templatized-bitfield.rs b/bindgen-tests/tests/expectations/tests/templatized-bitfield.rs new file mode 100644 index 0000000000..1b3e712361 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/templatized-bitfield.rs @@ -0,0 +1,9 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +/** We don't get a layout for this bitfield, since we don't know what `T` will + be, so we cannot allocate bitfield units. The best thing we can do is make + the struct opaque.*/ +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct TemplatizedBitfield { + pub _address: u8, +} diff --git a/bindgen-tests/tests/expectations/tests/test_macro_fallback_non_system_dir.rs b/bindgen-tests/tests/expectations/tests/test_macro_fallback_non_system_dir.rs new file mode 100644 index 0000000000..bf9739f3fa --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/test_macro_fallback_non_system_dir.rs @@ -0,0 +1,6 @@ +pub const CONST: u32 = 5; +pub const OTHER_CONST: u32 = 6; +pub const LARGE_CONST: u32 = 1536; +pub const THE_CONST: u32 = 28; +pub const MY_CONST: u32 = 69; +pub const NEGATIVE: i32 = -1; diff --git a/bindgen-tests/tests/expectations/tests/test_mixed_header_and_header_contents.rs b/bindgen-tests/tests/expectations/tests/test_mixed_header_and_header_contents.rs new file mode 100644 index 0000000000..e1872623bc --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/test_mixed_header_and_header_contents.rs @@ -0,0 +1,50 @@ +unsafe extern "C" { + pub static mut foo: ::std::option::Option< + unsafe extern "C" fn( + x: ::std::os::raw::c_int, + y: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >; +} +unsafe extern "C" { + pub fn bar(a: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bar2(b: *const ::std::os::raw::c_char) -> f32; +} +pub type Char = ::std::os::raw::c_char; +pub type SChar = ::std::os::raw::c_schar; +pub type UChar = ::std::os::raw::c_uchar; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Test { + pub ch: ::std::os::raw::c_char, + pub u: ::std::os::raw::c_uchar, + pub d: ::std::os::raw::c_schar, + pub cch: ::std::os::raw::c_char, + pub cu: ::std::os::raw::c_uchar, + pub cd: ::std::os::raw::c_schar, + pub Cch: Char, + pub Cu: UChar, + pub Cd: SChar, + pub Ccch: Char, + pub Ccu: UChar, + pub Ccd: SChar, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Test"][::std::mem::size_of::() - 12usize]; + ["Alignment of Test"][::std::mem::align_of::() - 1usize]; + ["Offset of field: Test::ch"][::std::mem::offset_of!(Test, ch) - 0usize]; + ["Offset of field: Test::u"][::std::mem::offset_of!(Test, u) - 1usize]; + ["Offset of field: Test::d"][::std::mem::offset_of!(Test, d) - 2usize]; + ["Offset of field: Test::cch"][::std::mem::offset_of!(Test, cch) - 3usize]; + ["Offset of field: Test::cu"][::std::mem::offset_of!(Test, cu) - 4usize]; + ["Offset of field: Test::cd"][::std::mem::offset_of!(Test, cd) - 5usize]; + ["Offset of field: Test::Cch"][::std::mem::offset_of!(Test, Cch) - 6usize]; + ["Offset of field: Test::Cu"][::std::mem::offset_of!(Test, Cu) - 7usize]; + ["Offset of field: Test::Cd"][::std::mem::offset_of!(Test, Cd) - 8usize]; + ["Offset of field: Test::Ccch"][::std::mem::offset_of!(Test, Ccch) - 9usize]; + ["Offset of field: Test::Ccu"][::std::mem::offset_of!(Test, Ccu) - 10usize]; + ["Offset of field: Test::Ccd"][::std::mem::offset_of!(Test, Ccd) - 11usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/test_multiple_header_calls_in_builder.rs b/bindgen-tests/tests/expectations/tests/test_multiple_header_calls_in_builder.rs new file mode 100644 index 0000000000..2e62ac902f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/test_multiple_header_calls_in_builder.rs @@ -0,0 +1,44 @@ +unsafe extern "C" { + pub static mut foo: ::std::option::Option< + unsafe extern "C" fn( + x: ::std::os::raw::c_int, + y: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >; +} +pub type Char = ::std::os::raw::c_char; +pub type SChar = ::std::os::raw::c_schar; +pub type UChar = ::std::os::raw::c_uchar; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Test { + pub ch: ::std::os::raw::c_char, + pub u: ::std::os::raw::c_uchar, + pub d: ::std::os::raw::c_schar, + pub cch: ::std::os::raw::c_char, + pub cu: ::std::os::raw::c_uchar, + pub cd: ::std::os::raw::c_schar, + pub Cch: Char, + pub Cu: UChar, + pub Cd: SChar, + pub Ccch: Char, + pub Ccu: UChar, + pub Ccd: SChar, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Test"][::std::mem::size_of::() - 12usize]; + ["Alignment of Test"][::std::mem::align_of::() - 1usize]; + ["Offset of field: Test::ch"][::std::mem::offset_of!(Test, ch) - 0usize]; + ["Offset of field: Test::u"][::std::mem::offset_of!(Test, u) - 1usize]; + ["Offset of field: Test::d"][::std::mem::offset_of!(Test, d) - 2usize]; + ["Offset of field: Test::cch"][::std::mem::offset_of!(Test, cch) - 3usize]; + ["Offset of field: Test::cu"][::std::mem::offset_of!(Test, cu) - 4usize]; + ["Offset of field: Test::cd"][::std::mem::offset_of!(Test, cd) - 5usize]; + ["Offset of field: Test::Cch"][::std::mem::offset_of!(Test, Cch) - 6usize]; + ["Offset of field: Test::Cu"][::std::mem::offset_of!(Test, Cu) - 7usize]; + ["Offset of field: Test::Cd"][::std::mem::offset_of!(Test, Cd) - 8usize]; + ["Offset of field: Test::Ccch"][::std::mem::offset_of!(Test, Ccch) - 9usize]; + ["Offset of field: Test::Ccu"][::std::mem::offset_of!(Test, Ccu) - 10usize]; + ["Offset of field: Test::Ccd"][::std::mem::offset_of!(Test, Ccd) - 11usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/timex.rs b/bindgen-tests/tests/expectations/tests/timex.rs new file mode 100644 index 0000000000..f73b608de2 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/timex.rs @@ -0,0 +1,589 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct timex { + pub tai: ::std::os::raw::c_int, + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 44usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of timex"][::std::mem::size_of::() - 48usize]; + ["Alignment of timex"][::std::mem::align_of::() - 4usize]; + ["Offset of field: timex::tai"][::std::mem::offset_of!(timex, tai) - 0usize]; +}; +impl Default for timex { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct timex_named { + pub tai: ::std::os::raw::c_int, + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 44usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of timex_named"][::std::mem::size_of::() - 48usize]; + ["Alignment of timex_named"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: timex_named::tai", + ][::std::mem::offset_of!(timex_named, tai) - 0usize]; +}; +impl Default for timex_named { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl timex_named { + #[inline] + pub fn a(&self) -> ::std::os::raw::c_int { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 32u8) as u32) } + } + #[inline] + pub fn set_a(&mut self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 32u8, val as u64) + } + } + #[inline] + pub unsafe fn a_raw(this: *const Self) -> ::std::os::raw::c_int { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 32u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_a_raw(this: *mut Self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 32u8, + val as u64, + ) + } + } + #[inline] + pub fn b(&self) -> ::std::os::raw::c_int { + unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 32u8) as u32) } + } + #[inline] + pub fn set_b(&mut self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(32usize, 32u8, val as u64) + } + } + #[inline] + pub unsafe fn b_raw(this: *const Self) -> ::std::os::raw::c_int { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 32usize, 32u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_b_raw(this: *mut Self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 32usize, + 32u8, + val as u64, + ) + } + } + #[inline] + pub fn c(&self) -> ::std::os::raw::c_int { + unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 32u8) as u32) } + } + #[inline] + pub fn set_c(&mut self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(64usize, 32u8, val as u64) + } + } + #[inline] + pub unsafe fn c_raw(this: *const Self) -> ::std::os::raw::c_int { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 64usize, 32u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_c_raw(this: *mut Self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 64usize, + 32u8, + val as u64, + ) + } + } + #[inline] + pub fn d(&self) -> ::std::os::raw::c_int { + unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 32u8) as u32) } + } + #[inline] + pub fn set_d(&mut self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(96usize, 32u8, val as u64) + } + } + #[inline] + pub unsafe fn d_raw(this: *const Self) -> ::std::os::raw::c_int { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 96usize, 32u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_d_raw(this: *mut Self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 96usize, + 32u8, + val as u64, + ) + } + } + #[inline] + pub fn e(&self) -> ::std::os::raw::c_int { + unsafe { ::std::mem::transmute(self._bitfield_1.get(128usize, 32u8) as u32) } + } + #[inline] + pub fn set_e(&mut self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(128usize, 32u8, val as u64) + } + } + #[inline] + pub unsafe fn e_raw(this: *const Self) -> ::std::os::raw::c_int { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 128usize, 32u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_e_raw(this: *mut Self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 128usize, + 32u8, + val as u64, + ) + } + } + #[inline] + pub fn f(&self) -> ::std::os::raw::c_int { + unsafe { ::std::mem::transmute(self._bitfield_1.get(160usize, 32u8) as u32) } + } + #[inline] + pub fn set_f(&mut self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(160usize, 32u8, val as u64) + } + } + #[inline] + pub unsafe fn f_raw(this: *const Self) -> ::std::os::raw::c_int { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 160usize, 32u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_f_raw(this: *mut Self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 160usize, + 32u8, + val as u64, + ) + } + } + #[inline] + pub fn g(&self) -> ::std::os::raw::c_int { + unsafe { ::std::mem::transmute(self._bitfield_1.get(192usize, 32u8) as u32) } + } + #[inline] + pub fn set_g(&mut self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(192usize, 32u8, val as u64) + } + } + #[inline] + pub unsafe fn g_raw(this: *const Self) -> ::std::os::raw::c_int { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 192usize, 32u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_g_raw(this: *mut Self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 192usize, + 32u8, + val as u64, + ) + } + } + #[inline] + pub fn h(&self) -> ::std::os::raw::c_int { + unsafe { ::std::mem::transmute(self._bitfield_1.get(224usize, 32u8) as u32) } + } + #[inline] + pub fn set_h(&mut self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(224usize, 32u8, val as u64) + } + } + #[inline] + pub unsafe fn h_raw(this: *const Self) -> ::std::os::raw::c_int { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 224usize, 32u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_h_raw(this: *mut Self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 224usize, + 32u8, + val as u64, + ) + } + } + #[inline] + pub fn i(&self) -> ::std::os::raw::c_int { + unsafe { ::std::mem::transmute(self._bitfield_1.get(256usize, 32u8) as u32) } + } + #[inline] + pub fn set_i(&mut self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(256usize, 32u8, val as u64) + } + } + #[inline] + pub unsafe fn i_raw(this: *const Self) -> ::std::os::raw::c_int { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 256usize, 32u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_i_raw(this: *mut Self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 256usize, + 32u8, + val as u64, + ) + } + } + #[inline] + pub fn j(&self) -> ::std::os::raw::c_int { + unsafe { ::std::mem::transmute(self._bitfield_1.get(288usize, 32u8) as u32) } + } + #[inline] + pub fn set_j(&mut self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(288usize, 32u8, val as u64) + } + } + #[inline] + pub unsafe fn j_raw(this: *const Self) -> ::std::os::raw::c_int { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 288usize, 32u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_j_raw(this: *mut Self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 288usize, + 32u8, + val as u64, + ) + } + } + #[inline] + pub fn k(&self) -> ::std::os::raw::c_int { + unsafe { ::std::mem::transmute(self._bitfield_1.get(320usize, 32u8) as u32) } + } + #[inline] + pub fn set_k(&mut self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(320usize, 32u8, val as u64) + } + } + #[inline] + pub unsafe fn k_raw(this: *const Self) -> ::std::os::raw::c_int { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 320usize, 32u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_k_raw(this: *mut Self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 44usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 320usize, + 32u8, + val as u64, + ) + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/transform-op.rs b/bindgen-tests/tests/expectations/tests/transform-op.rs new file mode 100644 index 0000000000..7a12f2abb7 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/transform-op.rs @@ -0,0 +1,251 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct __BindgenUnionField(::std::marker::PhantomData); +impl __BindgenUnionField { + #[inline] + pub const fn new() -> Self { + __BindgenUnionField(::std::marker::PhantomData) + } + #[inline] + pub unsafe fn as_ref(&self) -> &T { + ::std::mem::transmute(self) + } + #[inline] + pub unsafe fn as_mut(&mut self) -> &mut T { + ::std::mem::transmute(self) + } +} +impl ::std::default::Default for __BindgenUnionField { + #[inline] + fn default() -> Self { + Self::new() + } +} +impl ::std::clone::Clone for __BindgenUnionField { + #[inline] + fn clone(&self) -> Self { + *self + } +} +impl ::std::marker::Copy for __BindgenUnionField {} +impl ::std::fmt::Debug for __BindgenUnionField { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + fmt.write_str("__BindgenUnionField") + } +} +impl ::std::hash::Hash for __BindgenUnionField { + fn hash(&self, _state: &mut H) {} +} +impl ::std::cmp::PartialEq for __BindgenUnionField { + fn eq(&self, _other: &__BindgenUnionField) -> bool { + true + } +} +impl ::std::cmp::Eq for __BindgenUnionField {} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StylePoint { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub x: T, + pub y: T, +} +impl Default for StylePoint { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[repr(align(1))] +pub struct StyleFoo { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub __bindgen_anon_1: __BindgenUnionField, + pub foo: __BindgenUnionField>, + pub bar: __BindgenUnionField>, + pub baz: __BindgenUnionField>, + pub bindgen_union_field: [u8; 0usize], +} +pub const StyleFoo_Tag_Foo: StyleFoo_Tag = 0; +pub const StyleFoo_Tag_Bar: StyleFoo_Tag = 0; +pub const StyleFoo_Tag_Baz: StyleFoo_Tag = 0; +pub const StyleFoo_Tag_Bazz: StyleFoo_Tag = 0; +pub type StyleFoo_Tag = u8; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StyleFoo_Foo_Body { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub tag: StyleFoo_Tag, + pub x: i32, + pub y: StylePoint, + pub z: StylePoint, +} +impl Default for StyleFoo_Foo_Body { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StyleFoo_Bar_Body { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub tag: StyleFoo_Tag, + pub _0: T, +} +impl Default for StyleFoo_Bar_Body { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StyleFoo_Baz_Body { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub tag: StyleFoo_Tag, + pub _0: StylePoint, +} +impl Default for StyleFoo_Baz_Body { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StyleFoo__bindgen_ty_1 { + pub tag: StyleFoo_Tag, +} +impl Default for StyleFoo__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Default for StyleFoo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +pub struct StyleBar { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub tag: StyleBar_Tag, + pub __bindgen_anon_1: StyleBar__bindgen_ty_1, +} +pub const StyleBar_Tag_Bar1: StyleBar_Tag = 0; +pub const StyleBar_Tag_Bar2: StyleBar_Tag = 0; +pub const StyleBar_Tag_Bar3: StyleBar_Tag = 0; +pub const StyleBar_Tag_Bar4: StyleBar_Tag = 0; +pub type StyleBar_Tag = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StyleBar_StyleBar1_Body { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub x: i32, + pub y: StylePoint, + pub z: StylePoint, +} +impl Default for StyleBar_StyleBar1_Body { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StyleBar_StyleBar2_Body { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub _0: T, +} +impl Default for StyleBar_StyleBar2_Body { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StyleBar_StyleBar3_Body { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub _0: StylePoint, +} +impl Default for StyleBar_StyleBar3_Body { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[repr(align(1))] +pub struct StyleBar__bindgen_ty_1 { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub bar1: __BindgenUnionField>, + pub bar2: __BindgenUnionField>, + pub bar3: __BindgenUnionField>, + pub bindgen_union_field: [u8; 0usize], +} +impl Default for StyleBar__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Default for StyleBar { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: StylePoint_open0_float_close0", + ][::std::mem::size_of::>() - 8usize]; + [ + "Align of template specialization: StylePoint_open0_float_close0", + ][::std::mem::align_of::>() - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: StylePoint_open0_float_close0", + ][::std::mem::size_of::>() - 8usize]; + [ + "Align of template specialization: StylePoint_open0_float_close0", + ][::std::mem::align_of::>() - 4usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/type-referenced-by-allowlisted-function.rs b/bindgen-tests/tests/expectations/tests/type-referenced-by-allowlisted-function.rs new file mode 100644 index 0000000000..6d1c43d9cc --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/type-referenced-by-allowlisted-function.rs @@ -0,0 +1,17 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct dl_phdr_info { + pub x: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of dl_phdr_info"][::std::mem::size_of::() - 4usize]; + ["Alignment of dl_phdr_info"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: dl_phdr_info::x", + ][::std::mem::offset_of!(dl_phdr_info, x) - 0usize]; +}; +unsafe extern "C" { + pub fn dl_iterate_phdr(arg1: *mut dl_phdr_info) -> ::std::os::raw::c_int; +} diff --git a/bindgen-tests/tests/expectations/tests/type_alias_empty.rs b/bindgen-tests/tests/expectations/tests/type_alias_empty.rs new file mode 100644 index 0000000000..2cbeb75570 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/type_alias_empty.rs @@ -0,0 +1,2 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type bool_constant = u8; diff --git a/bindgen-tests/tests/expectations/tests/type_alias_partial_template_especialization.rs b/bindgen-tests/tests/expectations/tests/type_alias_partial_template_especialization.rs new file mode 100644 index 0000000000..29df017a9b --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/type_alias_partial_template_especialization.rs @@ -0,0 +1,17 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type MaybeWrapped = A; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Rooted { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub ptr: MaybeWrapped, +} +impl Default for Rooted { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/type_alias_template_specialized.rs b/bindgen-tests/tests/expectations/tests/type_alias_template_specialized.rs new file mode 100644 index 0000000000..13e3f8139c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/type_alias_template_specialized.rs @@ -0,0 +1,32 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Rooted { + pub ptr: MaybeWrapped<::std::os::raw::c_int>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Rooted"][::std::mem::size_of::() - 4usize]; + ["Alignment of Rooted"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Rooted::ptr"][::std::mem::offset_of!(Rooted, ptr) - 0usize]; +}; +impl Default for Rooted { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +///
+pub type MaybeWrapped = a; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: MaybeWrapped_open0_int_close0", + ][::std::mem::size_of::>() - 4usize]; + [ + "Align of template specialization: MaybeWrapped_open0_int_close0", + ][::std::mem::align_of::>() - 4usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/typedef-pointer-overlap.rs b/bindgen-tests/tests/expectations/tests/typedef-pointer-overlap.rs new file mode 100644 index 0000000000..122059b4e1 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/typedef-pointer-overlap.rs @@ -0,0 +1,87 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct foo { + pub inner: ::std::os::raw::c_char, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of foo"][::std::mem::align_of::() - 1usize]; + ["Offset of field: foo::inner"][::std::mem::offset_of!(foo, inner) - 0usize]; +}; +pub type foo_ptr = *const foo; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct bar { + pub inner: ::std::os::raw::c_char, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of bar"][::std::mem::size_of::() - 1usize]; + ["Alignment of bar"][::std::mem::align_of::() - 1usize]; + ["Offset of field: bar::inner"][::std::mem::offset_of!(bar, inner) - 0usize]; +}; +pub type bar_ptr = *mut bar; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct baz { + _unused: [u8; 0], +} +pub type baz_ptr = *mut baz; +#[repr(C)] +#[derive(Copy, Clone)] +pub union cat { + pub standard_issue: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of cat"][::std::mem::size_of::() - 4usize]; + ["Alignment of cat"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: cat::standard_issue", + ][::std::mem::offset_of!(cat, standard_issue) - 0usize]; +}; +impl Default for cat { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type cat_ptr = *mut cat; +pub const mad_scientist: mad = 0; +pub type mad = ::std::os::raw::c_uint; +pub type mad_ptr = *mut mad; +unsafe extern "C" { + pub fn takes_foo_ptr(arg1: foo_ptr); +} +unsafe extern "C" { + pub fn takes_foo_struct(arg1: foo); +} +unsafe extern "C" { + pub fn takes_bar_ptr(arg1: bar_ptr); +} +unsafe extern "C" { + pub fn takes_bar_struct(arg1: bar); +} +unsafe extern "C" { + pub fn takes_baz_ptr(arg1: baz_ptr); +} +unsafe extern "C" { + pub fn takes_baz_struct(arg1: baz); +} +unsafe extern "C" { + pub fn takes_cat_ptr(arg1: cat_ptr); +} +unsafe extern "C" { + pub fn takes_cat_union(arg1: cat); +} +unsafe extern "C" { + pub fn takes_mad_ptr(arg1: mad_ptr); +} +unsafe extern "C" { + pub fn takes_mad_enum(arg1: mad); +} diff --git a/bindgen-tests/tests/expectations/tests/typedefd-array-as-function-arg.rs b/bindgen-tests/tests/expectations/tests/typedefd-array-as-function-arg.rs new file mode 100644 index 0000000000..994b327da7 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/typedefd-array-as-function-arg.rs @@ -0,0 +1,5 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type myVector3 = [f32; 3usize]; +unsafe extern "C" { + pub fn modifyVectorFunc(v: *mut f32); +} diff --git a/bindgen-tests/tests/expectations/tests/typeref.rs b/bindgen-tests/tests/expectations/tests/typeref.rs new file mode 100644 index 0000000000..e48f0eb254 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/typeref.rs @@ -0,0 +1,105 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct mozilla_FragmentOrURL { + pub mIsLocalRef: bool, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of mozilla_FragmentOrURL", + ][::std::mem::size_of::() - 1usize]; + [ + "Alignment of mozilla_FragmentOrURL", + ][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: mozilla_FragmentOrURL::mIsLocalRef", + ][::std::mem::offset_of!(mozilla_FragmentOrURL, mIsLocalRef) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct mozilla_Position { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of mozilla_Position"][::std::mem::size_of::() - 1usize]; + [ + "Alignment of mozilla_Position", + ][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +pub struct mozilla_StyleShapeSource { + pub __bindgen_anon_1: mozilla_StyleShapeSource__bindgen_ty_1, +} +#[repr(C)] +pub union mozilla_StyleShapeSource__bindgen_ty_1 { + pub mPosition: *mut mozilla_Position, + pub mFragmentOrURL: *mut mozilla_FragmentOrURL, +} +impl Default for mozilla_StyleShapeSource__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Default for mozilla_StyleShapeSource { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Bar { + pub mFoo: *mut nsFoo, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 8usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Bar::mFoo"][::std::mem::offset_of!(Bar, mFoo) - 0usize]; +}; +impl Default for Bar { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +pub struct nsFoo { + pub mBar: mozilla_StyleShapeSource, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of nsFoo"][::std::mem::size_of::() - 8usize]; + ["Alignment of nsFoo"][::std::mem::align_of::() - 8usize]; + ["Offset of field: nsFoo::mBar"][::std::mem::offset_of!(nsFoo, mBar) - 0usize]; +}; +impl Default for nsFoo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of template specialization: mozilla_StyleShapeSource_open0_int_close0", + ][::std::mem::size_of::() - 8usize]; + [ + "Align of template specialization: mozilla_StyleShapeSource_open0_int_close0", + ][::std::mem::align_of::() - 8usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/uncallable_functions.rs b/bindgen-tests/tests/expectations/tests/uncallable_functions.rs new file mode 100644 index 0000000000..fddb5d41fc --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/uncallable_functions.rs @@ -0,0 +1,46 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct Test__bindgen_vtable { + pub Test_a: unsafe extern "C" fn(this: *mut Test), +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Test { + pub vtable_: *const Test__bindgen_vtable, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Test"][::std::mem::size_of::() - 8usize]; + ["Alignment of Test"][::std::mem::align_of::() - 8usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN4Test1bEv"] + pub fn Test_b(this: *mut Test); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN4Test1cEv"] + pub fn Test_c(this: *mut Test); +} +impl Default for Test { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Test { + #[inline] + pub unsafe fn b(&mut self) { + Test_b(self) + } + #[inline] + pub unsafe fn c(&mut self) { + Test_c(self) + } +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN4Test1aEv"] + pub fn Test_a(this: *mut ::std::os::raw::c_void); +} diff --git a/bindgen-tests/tests/expectations/tests/underscore.rs b/bindgen-tests/tests/expectations/tests/underscore.rs new file mode 100644 index 0000000000..f94d5fc580 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/underscore.rs @@ -0,0 +1,13 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const __: ::std::os::raw::c_int = 10; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct ptr_t { + pub __: [::std::os::raw::c_uchar; 8usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ptr_t"][::std::mem::size_of::() - 8usize]; + ["Alignment of ptr_t"][::std::mem::align_of::() - 1usize]; + ["Offset of field: ptr_t::__"][::std::mem::offset_of!(ptr_t, __) - 0usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/union-align.rs b/bindgen-tests/tests/expectations/tests/union-align.rs new file mode 100644 index 0000000000..bdb1bb376e --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/union-align.rs @@ -0,0 +1,43 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub union Bar { + pub foo: ::std::os::raw::c_uchar, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 16usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 16usize]; + ["Offset of field: Bar::foo"][::std::mem::offset_of!(Bar, foo) - 0usize]; +}; +impl Default for Bar { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub union Baz { + pub bar: Bar, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Baz"][::std::mem::size_of::() - 16usize]; + ["Alignment of Baz"][::std::mem::align_of::() - 16usize]; + ["Offset of field: Baz::bar"][::std::mem::offset_of!(Baz, bar) - 0usize]; +}; +impl Default for Baz { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/union-in-ns.rs b/bindgen-tests/tests/expectations/tests/union-in-ns.rs new file mode 100644 index 0000000000..781041addb --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/union-in-ns.rs @@ -0,0 +1,26 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub mod root { + #[allow(unused_imports)] + use self::super::root; + #[repr(C)] + #[derive(Copy, Clone)] + pub union bar { + pub baz: ::std::os::raw::c_int, + } + #[allow(clippy::unnecessary_operation, clippy::identity_op)] + const _: () = { + ["Size of bar"][::std::mem::size_of::() - 4usize]; + ["Alignment of bar"][::std::mem::align_of::() - 4usize]; + ["Offset of field: bar::baz"][::std::mem::offset_of!(bar, baz) - 0usize]; + }; + impl Default for bar { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/union_bitfield.rs b/bindgen-tests/tests/expectations/tests/union_bitfield.rs new file mode 100644 index 0000000000..8df0724738 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/union_bitfield.rs @@ -0,0 +1,340 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union U4 { + pub _bindgen_align: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of U4"][::std::mem::size_of::() - 4usize]; + ["Alignment of U4"][::std::mem::align_of::() - 4usize]; +}; +impl Default for U4 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl U4 { + #[inline] + pub fn derp(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_derp(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn derp_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_derp_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + derp: ::std::os::raw::c_uint, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let derp: u32 = unsafe { ::std::mem::transmute(derp) }; + derp as u64 + }, + ); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union B { + pub _bindgen_align: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of B"][::std::mem::size_of::() - 4usize]; + ["Alignment of B"][::std::mem::align_of::() - 4usize]; +}; +impl Default for B { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl B { + #[inline] + pub fn foo(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 31u8) as u32) } + } + #[inline] + pub fn set_foo(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn foo_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 31u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_foo_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn bar(&self) -> ::std::os::raw::c_uchar { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_bar(&mut self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bar_raw(this: *const Self) -> ::std::os::raw::c_uchar { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_bar_raw(this: *mut Self, val: ::std::os::raw::c_uchar) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 1usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + foo: ::std::os::raw::c_uint, + bar: ::std::os::raw::c_uchar, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 31u8, + { + let foo: u32 = unsafe { ::std::mem::transmute(foo) }; + foo as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let bar: u8 = unsafe { ::std::mem::transmute(bar) }; + bar as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/union_dtor.rs b/bindgen-tests/tests/expectations/tests/union_dtor.rs new file mode 100644 index 0000000000..3b89587098 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/union_dtor.rs @@ -0,0 +1,36 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub union UnionWithDtor { + pub mFoo: ::std::os::raw::c_int, + pub mBar: *mut ::std::os::raw::c_void, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of UnionWithDtor"][::std::mem::size_of::() - 8usize]; + ["Alignment of UnionWithDtor"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: UnionWithDtor::mFoo", + ][::std::mem::offset_of!(UnionWithDtor, mFoo) - 0usize]; + [ + "Offset of field: UnionWithDtor::mBar", + ][::std::mem::offset_of!(UnionWithDtor, mBar) - 0usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN13UnionWithDtorD1Ev"] + pub fn UnionWithDtor_UnionWithDtor_destructor(this: *mut UnionWithDtor); +} +impl Default for UnionWithDtor { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl UnionWithDtor { + #[inline] + pub unsafe fn destruct(&mut self) { + UnionWithDtor_UnionWithDtor_destructor(self) + } +} diff --git a/bindgen-tests/tests/expectations/tests/union_fields.rs b/bindgen-tests/tests/expectations/tests/union_fields.rs new file mode 100644 index 0000000000..c3d0f8db61 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/union_fields.rs @@ -0,0 +1,31 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone)] +pub union nsStyleUnion { + pub mInt: ::std::os::raw::c_int, + pub mFloat: f32, + pub mPointer: *mut ::std::os::raw::c_void, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of nsStyleUnion"][::std::mem::size_of::() - 8usize]; + ["Alignment of nsStyleUnion"][::std::mem::align_of::() - 8usize]; + [ + "Offset of field: nsStyleUnion::mInt", + ][::std::mem::offset_of!(nsStyleUnion, mInt) - 0usize]; + [ + "Offset of field: nsStyleUnion::mFloat", + ][::std::mem::offset_of!(nsStyleUnion, mFloat) - 0usize]; + [ + "Offset of field: nsStyleUnion::mPointer", + ][::std::mem::offset_of!(nsStyleUnion, mPointer) - 0usize]; +}; +impl Default for nsStyleUnion { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/union_template.rs b/bindgen-tests/tests/expectations/tests/union_template.rs new file mode 100644 index 0000000000..62019e6dd7 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/union_template.rs @@ -0,0 +1,58 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct NastyStruct { + pub mIsSome: bool, + pub mStorage: NastyStruct__bindgen_ty_1, + pub __bindgen_anon_1: NastyStruct__bindgen_ty_2, +} +#[repr(C)] +pub union NastyStruct__bindgen_ty_1 { + pub mFoo: *mut ::std::os::raw::c_void, + pub mDummy: ::std::os::raw::c_ulong, +} +impl Default for NastyStruct__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +pub union NastyStruct__bindgen_ty_2 { + pub wat: ::std::os::raw::c_short, + pub wut: *mut ::std::os::raw::c_int, +} +impl Default for NastyStruct__bindgen_ty_2 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Default for NastyStruct { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +pub union Whatever { + pub mTPtr: *mut ::std::os::raw::c_void, + pub mInt: ::std::os::raw::c_int, +} +impl Default for Whatever { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/union_with_anon_struct.rs b/bindgen-tests/tests/expectations/tests/union_with_anon_struct.rs new file mode 100644 index 0000000000..20f4dd2265 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/union_with_anon_struct.rs @@ -0,0 +1,40 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone)] +pub union foo { + pub bar: foo__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct foo__bindgen_ty_1 { + pub a: ::std::os::raw::c_uint, + pub b: ::std::os::raw::c_uint, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo__bindgen_ty_1"][::std::mem::size_of::() - 8usize]; + [ + "Alignment of foo__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: foo__bindgen_ty_1::a", + ][::std::mem::offset_of!(foo__bindgen_ty_1, a) - 0usize]; + [ + "Offset of field: foo__bindgen_ty_1::b", + ][::std::mem::offset_of!(foo__bindgen_ty_1, b) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 8usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::bar"][::std::mem::offset_of!(foo, bar) - 0usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield.rs b/bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield.rs new file mode 100644 index 0000000000..a1b61c035d --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield.rs @@ -0,0 +1,281 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union foo { + pub a: ::std::os::raw::c_int, + pub __bindgen_anon_1: foo__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct foo__bindgen_ty_1 { + pub _bindgen_align: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo__bindgen_ty_1"][::std::mem::size_of::() - 4usize]; + [ + "Alignment of foo__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; +}; +impl foo__bindgen_ty_1 { + #[inline] + pub fn b(&self) -> ::std::os::raw::c_int { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 7u8) as u32) } + } + #[inline] + pub fn set_b(&mut self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 7u8, val as u64) + } + } + #[inline] + pub unsafe fn b_raw(this: *const Self) -> ::std::os::raw::c_int { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 7u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_b_raw(this: *mut Self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 7u8, + val as u64, + ) + } + } + #[inline] + pub fn c(&self) -> ::std::os::raw::c_int { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 25u8) as u32) } + } + #[inline] + pub fn set_c(&mut self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 25u8, val as u64) + } + } + #[inline] + pub unsafe fn c_raw(this: *const Self) -> ::std::os::raw::c_int { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 7usize, 25u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_c_raw(this: *mut Self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 25u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + b: ::std::os::raw::c_int, + c: ::std::os::raw::c_int, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 7u8, + { + let b: u32 = unsafe { ::std::mem::transmute(b) }; + b as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 7usize, + 25u8, + { + let c: u32 = unsafe { ::std::mem::transmute(c) }; + c as u64 + }, + ); + __bindgen_bitfield_unit + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::a"][::std::mem::offset_of!(foo, a) - 0usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/union_with_anon_union.rs b/bindgen-tests/tests/expectations/tests/union_with_anon_union.rs new file mode 100644 index 0000000000..212a159cd2 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/union_with_anon_union.rs @@ -0,0 +1,49 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone)] +pub union foo { + pub bar: foo__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union foo__bindgen_ty_1 { + pub a: ::std::os::raw::c_uint, + pub b: ::std::os::raw::c_ushort, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo__bindgen_ty_1"][::std::mem::size_of::() - 4usize]; + [ + "Alignment of foo__bindgen_ty_1", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: foo__bindgen_ty_1::a", + ][::std::mem::offset_of!(foo__bindgen_ty_1, a) - 0usize]; + [ + "Offset of field: foo__bindgen_ty_1::b", + ][::std::mem::offset_of!(foo__bindgen_ty_1, b) - 0usize]; +}; +impl Default for foo__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::bar"][::std::mem::offset_of!(foo, bar) - 0usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_struct.rs b/bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_struct.rs new file mode 100644 index 0000000000..859188e891 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_struct.rs @@ -0,0 +1,51 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone)] +pub union pixel { + pub rgba: ::std::os::raw::c_uint, + pub __bindgen_anon_1: pixel__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] +pub struct pixel__bindgen_ty_1 { + pub r: ::std::os::raw::c_uchar, + pub g: ::std::os::raw::c_uchar, + pub b: ::std::os::raw::c_uchar, + pub a: ::std::os::raw::c_uchar, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of pixel__bindgen_ty_1", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of pixel__bindgen_ty_1", + ][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: pixel__bindgen_ty_1::r", + ][::std::mem::offset_of!(pixel__bindgen_ty_1, r) - 0usize]; + [ + "Offset of field: pixel__bindgen_ty_1::g", + ][::std::mem::offset_of!(pixel__bindgen_ty_1, g) - 1usize]; + [ + "Offset of field: pixel__bindgen_ty_1::b", + ][::std::mem::offset_of!(pixel__bindgen_ty_1, b) - 2usize]; + [ + "Offset of field: pixel__bindgen_ty_1::a", + ][::std::mem::offset_of!(pixel__bindgen_ty_1, a) - 3usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of pixel"][::std::mem::size_of::() - 4usize]; + ["Alignment of pixel"][::std::mem::align_of::() - 4usize]; + ["Offset of field: pixel::rgba"][::std::mem::offset_of!(pixel, rgba) - 0usize]; +}; +impl Default for pixel { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_union.rs b/bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_union.rs new file mode 100644 index 0000000000..6e136c0d92 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_union.rs @@ -0,0 +1,50 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone)] +pub union foo { + pub a: ::std::os::raw::c_uint, + pub __bindgen_anon_1: foo__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union foo__bindgen_ty_1 { + pub b: ::std::os::raw::c_ushort, + pub c: ::std::os::raw::c_uchar, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo__bindgen_ty_1"][::std::mem::size_of::() - 2usize]; + [ + "Alignment of foo__bindgen_ty_1", + ][::std::mem::align_of::() - 2usize]; + [ + "Offset of field: foo__bindgen_ty_1::b", + ][::std::mem::offset_of!(foo__bindgen_ty_1, b) - 0usize]; + [ + "Offset of field: foo__bindgen_ty_1::c", + ][::std::mem::offset_of!(foo__bindgen_ty_1, c) - 0usize]; +}; +impl Default for foo__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::a"][::std::mem::offset_of!(foo, a) - 0usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/union_with_big_member.rs b/bindgen-tests/tests/expectations/tests/union_with_big_member.rs new file mode 100644 index 0000000000..9d69957a85 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/union_with_big_member.rs @@ -0,0 +1,79 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone)] +pub union WithBigArray { + pub a: ::std::os::raw::c_int, + pub b: [::std::os::raw::c_int; 33usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of WithBigArray"][::std::mem::size_of::() - 132usize]; + ["Alignment of WithBigArray"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: WithBigArray::a", + ][::std::mem::offset_of!(WithBigArray, a) - 0usize]; + [ + "Offset of field: WithBigArray::b", + ][::std::mem::offset_of!(WithBigArray, b) - 0usize]; +}; +impl Default for WithBigArray { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union WithBigArray2 { + pub a: ::std::os::raw::c_int, + pub b: [::std::os::raw::c_char; 33usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of WithBigArray2"][::std::mem::size_of::() - 36usize]; + ["Alignment of WithBigArray2"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: WithBigArray2::a", + ][::std::mem::offset_of!(WithBigArray2, a) - 0usize]; + [ + "Offset of field: WithBigArray2::b", + ][::std::mem::offset_of!(WithBigArray2, b) - 0usize]; +}; +impl Default for WithBigArray2 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union WithBigMember { + pub a: ::std::os::raw::c_int, + pub b: WithBigArray, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of WithBigMember"][::std::mem::size_of::() - 132usize]; + ["Alignment of WithBigMember"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: WithBigMember::a", + ][::std::mem::offset_of!(WithBigMember, a) - 0usize]; + [ + "Offset of field: WithBigMember::b", + ][::std::mem::offset_of!(WithBigMember, b) - 0usize]; +}; +impl Default for WithBigMember { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/union_with_nesting.rs b/bindgen-tests/tests/expectations/tests/union_with_nesting.rs new file mode 100644 index 0000000000..5b60193ba4 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/union_with_nesting.rs @@ -0,0 +1,104 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone)] +pub union foo { + pub a: ::std::os::raw::c_uint, + pub __bindgen_anon_1: foo__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct foo__bindgen_ty_1 { + pub __bindgen_anon_1: foo__bindgen_ty_1__bindgen_ty_1, + pub __bindgen_anon_2: foo__bindgen_ty_1__bindgen_ty_2, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union foo__bindgen_ty_1__bindgen_ty_1 { + pub b1: ::std::os::raw::c_ushort, + pub b2: ::std::os::raw::c_ushort, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of foo__bindgen_ty_1__bindgen_ty_1", + ][::std::mem::size_of::() - 2usize]; + [ + "Alignment of foo__bindgen_ty_1__bindgen_ty_1", + ][::std::mem::align_of::() - 2usize]; + [ + "Offset of field: foo__bindgen_ty_1__bindgen_ty_1::b1", + ][::std::mem::offset_of!(foo__bindgen_ty_1__bindgen_ty_1, b1) - 0usize]; + [ + "Offset of field: foo__bindgen_ty_1__bindgen_ty_1::b2", + ][::std::mem::offset_of!(foo__bindgen_ty_1__bindgen_ty_1, b2) - 0usize]; +}; +impl Default for foo__bindgen_ty_1__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union foo__bindgen_ty_1__bindgen_ty_2 { + pub c1: ::std::os::raw::c_ushort, + pub c2: ::std::os::raw::c_ushort, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of foo__bindgen_ty_1__bindgen_ty_2", + ][::std::mem::size_of::() - 2usize]; + [ + "Alignment of foo__bindgen_ty_1__bindgen_ty_2", + ][::std::mem::align_of::() - 2usize]; + [ + "Offset of field: foo__bindgen_ty_1__bindgen_ty_2::c1", + ][::std::mem::offset_of!(foo__bindgen_ty_1__bindgen_ty_2, c1) - 0usize]; + [ + "Offset of field: foo__bindgen_ty_1__bindgen_ty_2::c2", + ][::std::mem::offset_of!(foo__bindgen_ty_1__bindgen_ty_2, c2) - 0usize]; +}; +impl Default for foo__bindgen_ty_1__bindgen_ty_2 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo__bindgen_ty_1"][::std::mem::size_of::() - 4usize]; + [ + "Alignment of foo__bindgen_ty_1", + ][::std::mem::align_of::() - 2usize]; +}; +impl Default for foo__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 4usize]; + ["Alignment of foo"][::std::mem::align_of::() - 4usize]; + ["Offset of field: foo::a"][::std::mem::offset_of!(foo, a) - 0usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/union_with_non_copy_member.rs b/bindgen-tests/tests/expectations/tests/union_with_non_copy_member.rs new file mode 100644 index 0000000000..d13c24d2d8 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/union_with_non_copy_member.rs @@ -0,0 +1,142 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct __BindgenUnionField(::std::marker::PhantomData); +impl __BindgenUnionField { + #[inline] + pub const fn new() -> Self { + __BindgenUnionField(::std::marker::PhantomData) + } + #[inline] + pub unsafe fn as_ref(&self) -> &T { + ::std::mem::transmute(self) + } + #[inline] + pub unsafe fn as_mut(&mut self) -> &mut T { + ::std::mem::transmute(self) + } +} +impl ::std::default::Default for __BindgenUnionField { + #[inline] + fn default() -> Self { + Self::new() + } +} +impl ::std::clone::Clone for __BindgenUnionField { + #[inline] + fn clone(&self) -> Self { + *self + } +} +impl ::std::marker::Copy for __BindgenUnionField {} +impl ::std::fmt::Debug for __BindgenUnionField { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + fmt.write_str("__BindgenUnionField") + } +} +impl ::std::hash::Hash for __BindgenUnionField { + fn hash(&self, _state: &mut H) {} +} +impl ::std::cmp::PartialEq for __BindgenUnionField { + fn eq(&self, _other: &__BindgenUnionField) -> bool { + true + } +} +impl ::std::cmp::Eq for __BindgenUnionField {} +#[repr(C)] +#[derive(Debug, Default)] +pub struct NonCopyType { + pub foo: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of NonCopyType"][::std::mem::size_of::() - 4usize]; + ["Alignment of NonCopyType"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: NonCopyType::foo", + ][::std::mem::offset_of!(NonCopyType, foo) - 0usize]; +}; +#[repr(C)] +pub struct WithBindgenGeneratedWrapper { + pub non_copy_type: __BindgenUnionField, + pub bar: __BindgenUnionField<::std::os::raw::c_int>, + pub bindgen_union_field: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of WithBindgenGeneratedWrapper", + ][::std::mem::size_of::() - 4usize]; + [ + "Alignment of WithBindgenGeneratedWrapper", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: WithBindgenGeneratedWrapper::non_copy_type", + ][::std::mem::offset_of!(WithBindgenGeneratedWrapper, non_copy_type) - 0usize]; + [ + "Offset of field: WithBindgenGeneratedWrapper::bar", + ][::std::mem::offset_of!(WithBindgenGeneratedWrapper, bar) - 0usize]; +}; +impl Default for WithBindgenGeneratedWrapper { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +pub union WithManuallyDrop { + pub non_copy_type: ::std::mem::ManuallyDrop, + pub bar: ::std::mem::ManuallyDrop<::std::os::raw::c_int>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of WithManuallyDrop"][::std::mem::size_of::() - 4usize]; + [ + "Alignment of WithManuallyDrop", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: WithManuallyDrop::non_copy_type", + ][::std::mem::offset_of!(WithManuallyDrop, non_copy_type) - 0usize]; + [ + "Offset of field: WithManuallyDrop::bar", + ][::std::mem::offset_of!(WithManuallyDrop, bar) - 0usize]; +}; +impl Default for WithManuallyDrop { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +pub struct WithDefaultWrapper { + pub non_copy_type: __BindgenUnionField, + pub bar: __BindgenUnionField<::std::os::raw::c_int>, + pub bindgen_union_field: u32, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of WithDefaultWrapper"][::std::mem::size_of::() - 4usize]; + [ + "Alignment of WithDefaultWrapper", + ][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: WithDefaultWrapper::non_copy_type", + ][::std::mem::offset_of!(WithDefaultWrapper, non_copy_type) - 0usize]; + [ + "Offset of field: WithDefaultWrapper::bar", + ][::std::mem::offset_of!(WithDefaultWrapper, bar) - 0usize]; +}; +impl Default for WithDefaultWrapper { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/union_with_zero_sized_array.rs b/bindgen-tests/tests/expectations/tests/union_with_zero_sized_array.rs new file mode 100644 index 0000000000..aa23fcd734 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/union_with_zero_sized_array.rs @@ -0,0 +1,68 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct __BindgenUnionField(::std::marker::PhantomData); +impl __BindgenUnionField { + #[inline] + pub const fn new() -> Self { + __BindgenUnionField(::std::marker::PhantomData) + } + #[inline] + pub unsafe fn as_ref(&self) -> &T { + ::std::mem::transmute(self) + } + #[inline] + pub unsafe fn as_mut(&mut self) -> &mut T { + ::std::mem::transmute(self) + } +} +impl ::std::default::Default for __BindgenUnionField { + #[inline] + fn default() -> Self { + Self::new() + } +} +impl ::std::clone::Clone for __BindgenUnionField { + #[inline] + fn clone(&self) -> Self { + *self + } +} +impl ::std::marker::Copy for __BindgenUnionField {} +impl ::std::fmt::Debug for __BindgenUnionField { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + fmt.write_str("__BindgenUnionField") + } +} +impl ::std::hash::Hash for __BindgenUnionField { + fn hash(&self, _state: &mut H) {} +} +impl ::std::cmp::PartialEq for __BindgenUnionField { + fn eq(&self, _other: &__BindgenUnionField) -> bool { + true + } +} +impl ::std::cmp::Eq for __BindgenUnionField {} +#[repr(C)] +pub struct U { + pub d0: __BindgenUnionField<[::std::os::raw::c_char; 0usize]>, + pub d1: __BindgenUnionField<[::std::os::raw::c_char; 1usize]>, + pub d2: __BindgenUnionField<[::std::os::raw::c_char; 2usize]>, + pub bindgen_union_field: [u8; 2usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of U"][::std::mem::size_of::() - 2usize]; + ["Alignment of U"][::std::mem::align_of::() - 1usize]; + ["Offset of field: U::d0"][::std::mem::offset_of!(U, d0) - 0usize]; + ["Offset of field: U::d1"][::std::mem::offset_of!(U, d1) - 0usize]; + ["Offset of field: U::d2"][::std::mem::offset_of!(U, d2) - 0usize]; +}; +impl Default for U { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/unknown_attr.rs b/bindgen-tests/tests/expectations/tests/unknown_attr.rs new file mode 100644 index 0000000000..d749dad977 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/unknown_attr.rs @@ -0,0 +1,28 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)] +#[repr(C, align(8))] +pub struct __BindgenOpaqueArray8(pub T); +impl Default for __BindgenOpaqueArray8<[T; N]> { + fn default() -> Self { + Self([::default(); N]) + } +} +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Default, Copy, Clone)] +pub struct max_align_t { + pub __clang_max_align_nonce1: ::std::os::raw::c_longlong, + pub __bindgen_padding_0: __BindgenOpaqueArray8<[u8; 8usize]>, + pub __clang_max_align_nonce2: ::std::os::raw::c_longlong, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of max_align_t"][::std::mem::size_of::() - 32usize]; + ["Alignment of max_align_t"][::std::mem::align_of::() - 16usize]; + [ + "Offset of field: max_align_t::__clang_max_align_nonce1", + ][::std::mem::offset_of!(max_align_t, __clang_max_align_nonce1) - 0usize]; + [ + "Offset of field: max_align_t::__clang_max_align_nonce2", + ][::std::mem::offset_of!(max_align_t, __clang_max_align_nonce2) - 16usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/unsorted-items.rs b/bindgen-tests/tests/expectations/tests/unsorted-items.rs new file mode 100644 index 0000000000..7d31c222a1 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/unsorted-items.rs @@ -0,0 +1,38 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn foo() -> ::std::os::raw::c_int; +} +pub type number = ::std::os::raw::c_int; +unsafe extern "C" { + pub fn bar(x: number) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Point { + pub x: number, + pub y: number, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Point"][::std::mem::size_of::() - 8usize]; + ["Alignment of Point"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Point::x"][::std::mem::offset_of!(Point, x) - 0usize]; + ["Offset of field: Point::y"][::std::mem::offset_of!(Point, y) - 4usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Angle { + pub a: number, + pub b: number, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Angle"][::std::mem::size_of::() - 8usize]; + ["Alignment of Angle"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Angle::a"][::std::mem::offset_of!(Angle, a) - 0usize]; + ["Offset of field: Angle::b"][::std::mem::offset_of!(Angle, b) - 4usize]; +}; +unsafe extern "C" { + pub fn baz(point: Point) -> ::std::os::raw::c_int; +} +pub const NUMBER: number = 42; diff --git a/bindgen-tests/tests/expectations/tests/use-core.rs b/bindgen-tests/tests/expectations/tests/use-core.rs new file mode 100644 index 0000000000..8d495459a0 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/use-core.rs @@ -0,0 +1,59 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(not(target_os = "windows"))] +extern crate core; +#[repr(C)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct foo { + pub a: ::core::ffi::c_int, + pub b: ::core::ffi::c_int, + pub bar: *mut ::core::ffi::c_void, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::core::mem::size_of::() - 16usize]; + ["Alignment of foo"][::core::mem::align_of::() - 8usize]; + ["Offset of field: foo::a"][::core::mem::offset_of!(foo, a) - 0usize]; + ["Offset of field: foo::b"][::core::mem::offset_of!(foo, b) - 4usize]; + ["Offset of field: foo::bar"][::core::mem::offset_of!(foo, bar) - 8usize]; +}; +impl Default for foo { + fn default() -> Self { + let mut s = ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _bindgen_ty_1 { + pub bar: ::core::ffi::c_int, + pub baz: ::core::ffi::c_long, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _bindgen_ty_1"][::core::mem::size_of::<_bindgen_ty_1>() - 8usize]; + ["Alignment of _bindgen_ty_1"][::core::mem::align_of::<_bindgen_ty_1>() - 8usize]; + [ + "Offset of field: _bindgen_ty_1::bar", + ][::core::mem::offset_of!(_bindgen_ty_1, bar) - 0usize]; + [ + "Offset of field: _bindgen_ty_1::baz", + ][::core::mem::offset_of!(_bindgen_ty_1, baz) - 0usize]; +}; +impl Default for _bindgen_ty_1 { + fn default() -> Self { + let mut s = ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +unsafe extern "C" { + pub static mut bazz: _bindgen_ty_1; +} +pub type fooFunction = ::core::option::Option< + unsafe extern "C" fn(bar: ::core::ffi::c_int), +>; diff --git a/bindgen-tests/tests/expectations/tests/using.rs b/bindgen-tests/tests/expectations/tests/using.rs new file mode 100644 index 0000000000..9737fef0a5 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/using.rs @@ -0,0 +1,19 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Point { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub x: T, + pub y: T, +} +impl Default for Point { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type IntPoint2D = Point<::std::os::raw::c_int>; +pub type IntVec2D = Point<::std::os::raw::c_int>; diff --git a/bindgen-tests/tests/expectations/tests/va_list_aarch64_linux.rs b/bindgen-tests/tests/expectations/tests/va_list_aarch64_linux.rs new file mode 100644 index 0000000000..b33f4894c1 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/va_list_aarch64_linux.rs @@ -0,0 +1,16 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)] +#[repr(C, align(8))] +pub struct __BindgenOpaqueArray8(pub T); +impl Default for __BindgenOpaqueArray8<[T; N]> { + fn default() -> Self { + Self([::default(); N]) + } +} +pub type va_list = __BindgenOpaqueArray8<[u8; 32usize]>; +unsafe extern "C" { + pub fn vprintf( + format: *const ::std::os::raw::c_char, + vlist: __BindgenOpaqueArray8<[u8; 32usize]>, + ) -> ::std::os::raw::c_int; +} diff --git a/bindgen-tests/tests/expectations/tests/var-tracing.rs b/bindgen-tests/tests/expectations/tests/var-tracing.rs new file mode 100644 index 0000000000..76ce0c50d6 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/var-tracing.rs @@ -0,0 +1,38 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Bar { + pub m_baz: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 4usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Bar::m_baz"][::std::mem::offset_of!(Bar, m_baz) - 0usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN3BarC1Ei"] + pub fn Bar_Bar(this: *mut Bar, baz: ::std::os::raw::c_int); +} +impl Bar { + #[inline] + pub unsafe fn new(baz: ::std::os::raw::c_int) -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + Bar_Bar(__bindgen_tmp.as_mut_ptr(), baz); + __bindgen_tmp.assume_init() + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Baz { + pub _address: u8, +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN3Baz3FOOE"] + pub static Baz_FOO: [Bar; 0usize]; +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Baz"][::std::mem::size_of::() - 1usize]; + ["Alignment of Baz"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/variadic-method.rs b/bindgen-tests/tests/expectations/tests/variadic-method.rs new file mode 100644 index 0000000000..deac5f719e --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/variadic-method.rs @@ -0,0 +1,19 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + #[link_name = "\u{1}_Z3fooPKcz"] + pub fn foo(fmt: *const ::std::os::raw::c_char, ...); +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Bar { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Bar"][::std::mem::size_of::() - 1usize]; + ["Alignment of Bar"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN3Bar3fooEPKcz"] + pub fn Bar_foo(this: *mut Bar, fmt: *const ::std::os::raw::c_char, ...); +} diff --git a/bindgen-tests/tests/expectations/tests/variadic-union.rs b/bindgen-tests/tests/expectations/tests/variadic-union.rs new file mode 100644 index 0000000000..471c9e7075 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/variadic-union.rs @@ -0,0 +1,14 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub union _Variadic_union { + pub _address: u8, +} +impl Default for _Variadic_union { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/variadic_template_function.rs b/bindgen-tests/tests/expectations/tests/variadic_template_function.rs new file mode 100644 index 0000000000..ee945f2599 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/variadic_template_function.rs @@ -0,0 +1,6 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct VariadicFunctionObject { + pub _address: u8, +} diff --git a/bindgen-tests/tests/expectations/tests/vector.rs b/bindgen-tests/tests/expectations/tests/vector.rs new file mode 100644 index 0000000000..da53b4a8eb --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/vector.rs @@ -0,0 +1,19 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct foo { + pub mMember: [::std::os::raw::c_longlong; 1usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 8usize]; + ["Alignment of foo"][::std::mem::align_of::() - 8usize]; + ["Offset of field: foo::mMember"][::std::mem::offset_of!(foo, mMember) - 0usize]; +}; +pub type __m128 = [f32; 4usize]; +pub type __m128d = [f64; 2usize]; +pub type __m128i = [::std::os::raw::c_longlong; 2usize]; +unsafe extern "C" { + #[link_name = "\u{1}_Z3fooDv2_xDv2_d"] + pub fn foo(arg1: __m128i, arg2: __m128d) -> __m128; +} diff --git a/bindgen-tests/tests/expectations/tests/virtual_dtor.rs b/bindgen-tests/tests/expectations/tests/virtual_dtor.rs new file mode 100644 index 0000000000..d42be25202 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/virtual_dtor.rs @@ -0,0 +1,26 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct nsSlots__bindgen_vtable(::std::os::raw::c_void); +#[repr(C)] +#[derive(Debug)] +pub struct nsSlots { + pub vtable_: *const nsSlots__bindgen_vtable, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of nsSlots"][::std::mem::size_of::() - 8usize]; + ["Alignment of nsSlots"][::std::mem::align_of::() - 8usize]; +}; +impl Default for nsSlots { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN7nsSlotsD1Ev"] + pub fn nsSlots_nsSlots_destructor(this: *mut nsSlots); +} diff --git a/bindgen-tests/tests/expectations/tests/virtual_inheritance.rs b/bindgen-tests/tests/expectations/tests/virtual_inheritance.rs new file mode 100644 index 0000000000..6b5a855fae --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/virtual_inheritance.rs @@ -0,0 +1,56 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct A { + pub foo: ::std::os::raw::c_int, +} +#[repr(C)] +pub struct B__bindgen_vtable(::std::os::raw::c_void); +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct B { + pub vtable_: *const B__bindgen_vtable, + pub bar: ::std::os::raw::c_int, +} +impl Default for B { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +pub struct C__bindgen_vtable(::std::os::raw::c_void); +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct C { + pub vtable_: *const C__bindgen_vtable, + pub baz: ::std::os::raw::c_int, +} +impl Default for C { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct D { + pub _base: C, + pub _base_1: B, + pub bazz: ::std::os::raw::c_int, +} +impl Default for D { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/virtual_interface.rs b/bindgen-tests/tests/expectations/tests/virtual_interface.rs new file mode 100644 index 0000000000..44b245c4ea --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/virtual_interface.rs @@ -0,0 +1,94 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct PureVirtualIFace__bindgen_vtable { + pub PureVirtualIFace_Foo: unsafe extern "C" fn(this: *mut PureVirtualIFace), + pub PureVirtualIFace_Bar: unsafe extern "C" fn( + this: *mut PureVirtualIFace, + arg1: ::std::os::raw::c_uint, + ), +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct PureVirtualIFace { + pub vtable_: *const PureVirtualIFace__bindgen_vtable, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of PureVirtualIFace"][::std::mem::size_of::() - 8usize]; + [ + "Alignment of PureVirtualIFace", + ][::std::mem::align_of::() - 8usize]; +}; +impl Default for PureVirtualIFace { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +pub struct AnotherInterface__bindgen_vtable { + pub AnotherInterface_Baz: unsafe extern "C" fn(this: *mut AnotherInterface), +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct AnotherInterface { + pub vtable_: *const AnotherInterface__bindgen_vtable, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of AnotherInterface"][::std::mem::size_of::() - 8usize]; + [ + "Alignment of AnotherInterface", + ][::std::mem::align_of::() - 8usize]; +}; +impl Default for AnotherInterface { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Implementation { + pub _base: PureVirtualIFace, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Implementation"][::std::mem::size_of::() - 8usize]; + ["Alignment of Implementation"][::std::mem::align_of::() - 8usize]; +}; +impl Default for Implementation { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct DoubleImpl { + pub _base: PureVirtualIFace, + pub _base_1: AnotherInterface, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of DoubleImpl"][::std::mem::size_of::() - 16usize]; + ["Alignment of DoubleImpl"][::std::mem::align_of::() - 8usize]; +}; +impl Default for DoubleImpl { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/virtual_overloaded.rs b/bindgen-tests/tests/expectations/tests/virtual_overloaded.rs new file mode 100644 index 0000000000..4c3702faeb --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/virtual_overloaded.rs @@ -0,0 +1,33 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct C__bindgen_vtable { + pub C_do_thing: unsafe extern "C" fn(this: *mut C, arg1: ::std::os::raw::c_char), + pub C_do_thing1: unsafe extern "C" fn(this: *mut C, arg1: ::std::os::raw::c_int), +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct C { + pub vtable_: *const C__bindgen_vtable, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of C"][::std::mem::size_of::() - 8usize]; + ["Alignment of C"][::std::mem::align_of::() - 8usize]; +}; +impl Default for C { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN1C8do_thingEc"] + pub fn C_do_thing(this: *mut ::std::os::raw::c_void, arg1: ::std::os::raw::c_char); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN1C8do_thingEi"] + pub fn C_do_thing1(this: *mut ::std::os::raw::c_void, arg1: ::std::os::raw::c_int); +} diff --git a/bindgen-tests/tests/expectations/tests/void_typedef.rs b/bindgen-tests/tests/expectations/tests/void_typedef.rs new file mode 100644 index 0000000000..4997d49086 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/void_typedef.rs @@ -0,0 +1,12 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub type VOID = ::std::os::raw::c_void; +pub type ALSO_VOID = VOID; +unsafe extern "C" { + pub fn this_api_returns_nothing(); +} +unsafe extern "C" { + pub fn this_api_also_returns_nothing(); +} +unsafe extern "C" { + pub fn this_other_api_also_returns_nothing(); +} diff --git a/bindgen-tests/tests/expectations/tests/vtable_recursive_sig.rs b/bindgen-tests/tests/expectations/tests/vtable_recursive_sig.rs new file mode 100644 index 0000000000..9b9c2467aa --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/vtable_recursive_sig.rs @@ -0,0 +1,47 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct Base__bindgen_vtable { + pub Base_AsDerived: unsafe extern "C" fn(this: *mut Base) -> *mut Derived, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Base { + pub vtable_: *const Base__bindgen_vtable, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Base"][::std::mem::size_of::() - 8usize]; + ["Alignment of Base"][::std::mem::align_of::() - 8usize]; +}; +impl Default for Base { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN4Base9AsDerivedEv"] + pub fn Base_AsDerived(this: *mut ::std::os::raw::c_void) -> *mut Derived; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Derived { + pub _base: Base, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Derived"][::std::mem::size_of::() - 8usize]; + ["Alignment of Derived"][::std::mem::align_of::() - 8usize]; +}; +impl Default for Derived { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/wasm-constructor-returns.rs b/bindgen-tests/tests/expectations/tests/wasm-constructor-returns.rs new file mode 100644 index 0000000000..ee26600a6b --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/wasm-constructor-returns.rs @@ -0,0 +1,26 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}_ZN3FooC1Ei"] + pub fn Foo_Foo( + this: *mut Foo, + var: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +impl Foo { + #[inline] + pub unsafe fn new(var: ::std::os::raw::c_int) -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + Foo_Foo(__bindgen_tmp.as_mut_ptr(), var); + __bindgen_tmp.assume_init() + } +} diff --git a/bindgen-tests/tests/expectations/tests/wasm-import-module.rs b/bindgen-tests/tests/expectations/tests/wasm-import-module.rs new file mode 100644 index 0000000000..aeeb17f1c1 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/wasm-import-module.rs @@ -0,0 +1,5 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[link(wasm_import_module = "test-module")] +unsafe extern "C" { + pub fn test_function(); +} diff --git a/bindgen-tests/tests/expectations/tests/weird_bitfields.rs b/bindgen-tests/tests/expectations/tests/weird_bitfields.rs new file mode 100644 index 0000000000..ca8d84520b --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/weird_bitfields.rs @@ -0,0 +1,574 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8) + .offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { byte | mask } else { byte & !mask } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8) + .offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!( + (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + ); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum nsStyleSVGOpacitySource { + eStyleSVGOpacitySource_Normal = 0, + eStyleSVGOpacitySource_ContextFillOpacity = 1, + eStyleSVGOpacitySource_ContextStrokeOpacity = 2, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Weird { + pub mStrokeDasharrayLength: ::std::os::raw::c_uint, + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + pub mClipRule: ::std::os::raw::c_uchar, + pub mColorInterpolation: ::std::os::raw::c_uchar, + pub mColorInterpolationFilters: ::std::os::raw::c_uchar, + pub mFillRule: ::std::os::raw::c_uchar, + pub mImageRendering: ::std::os::raw::c_uchar, + pub mPaintOrder: ::std::os::raw::c_uchar, + pub mShapeRendering: ::std::os::raw::c_uchar, + pub mStrokeLinecap: ::std::os::raw::c_uchar, + pub mStrokeLinejoin: ::std::os::raw::c_uchar, + pub mTextAnchor: ::std::os::raw::c_uchar, + pub mTextRendering: ::std::os::raw::c_uchar, + pub _bitfield_2: __BindgenBitfieldUnit<[u8; 2usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Weird"][::std::mem::size_of::() - 24usize]; + ["Alignment of Weird"][::std::mem::align_of::() - 4usize]; + [ + "Offset of field: Weird::mStrokeDasharrayLength", + ][::std::mem::offset_of!(Weird, mStrokeDasharrayLength) - 0usize]; + [ + "Offset of field: Weird::mClipRule", + ][::std::mem::offset_of!(Weird, mClipRule) - 8usize]; + [ + "Offset of field: Weird::mColorInterpolation", + ][::std::mem::offset_of!(Weird, mColorInterpolation) - 9usize]; + [ + "Offset of field: Weird::mColorInterpolationFilters", + ][::std::mem::offset_of!(Weird, mColorInterpolationFilters) - 10usize]; + [ + "Offset of field: Weird::mFillRule", + ][::std::mem::offset_of!(Weird, mFillRule) - 11usize]; + [ + "Offset of field: Weird::mImageRendering", + ][::std::mem::offset_of!(Weird, mImageRendering) - 12usize]; + [ + "Offset of field: Weird::mPaintOrder", + ][::std::mem::offset_of!(Weird, mPaintOrder) - 13usize]; + [ + "Offset of field: Weird::mShapeRendering", + ][::std::mem::offset_of!(Weird, mShapeRendering) - 14usize]; + [ + "Offset of field: Weird::mStrokeLinecap", + ][::std::mem::offset_of!(Weird, mStrokeLinecap) - 15usize]; + [ + "Offset of field: Weird::mStrokeLinejoin", + ][::std::mem::offset_of!(Weird, mStrokeLinejoin) - 16usize]; + [ + "Offset of field: Weird::mTextAnchor", + ][::std::mem::offset_of!(Weird, mTextAnchor) - 17usize]; + [ + "Offset of field: Weird::mTextRendering", + ][::std::mem::offset_of!(Weird, mTextRendering) - 18usize]; +}; +impl Default for Weird { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Weird { + #[inline] + pub fn bitTest(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) } + } + #[inline] + pub fn set_bitTest(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 16u8, val as u64) + } + } + #[inline] + pub unsafe fn bitTest_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 16u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bitTest_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 16u8, + val as u64, + ) + } + } + #[inline] + pub fn bitTest2(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 15u8) as u32) } + } + #[inline] + pub fn set_bitTest2(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 15u8, val as u64) + } + } + #[inline] + pub unsafe fn bitTest2_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 16usize, 15u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_bitTest2_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 4usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 15u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bitTest: ::std::os::raw::c_uint, + bitTest2: ::std::os::raw::c_uint, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 16u8, + { + let bitTest: u32 = unsafe { ::std::mem::transmute(bitTest) }; + bitTest as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 16usize, + 15u8, + { + let bitTest2: u32 = unsafe { ::std::mem::transmute(bitTest2) }; + bitTest2 as u64 + }, + ); + __bindgen_bitfield_unit + } + #[inline] + pub fn mFillOpacitySource(&self) -> nsStyleSVGOpacitySource { + unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 3u8) as u32) } + } + #[inline] + pub fn set_mFillOpacitySource(&mut self, val: nsStyleSVGOpacitySource) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_2.set(0usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn mFillOpacitySource_raw(this: *const Self) -> nsStyleSVGOpacitySource { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_2), 0usize, 3u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_mFillOpacitySource_raw( + this: *mut Self, + val: nsStyleSVGOpacitySource, + ) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 0usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn mStrokeOpacitySource(&self) -> nsStyleSVGOpacitySource { + unsafe { ::std::mem::transmute(self._bitfield_2.get(3usize, 3u8) as u32) } + } + #[inline] + pub fn set_mStrokeOpacitySource(&mut self, val: nsStyleSVGOpacitySource) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_2.set(3usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn mStrokeOpacitySource_raw( + this: *const Self, + ) -> nsStyleSVGOpacitySource { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_2), 3usize, 3u8) + as u32, + ) + } + } + #[inline] + pub unsafe fn set_mStrokeOpacitySource_raw( + this: *mut Self, + val: nsStyleSVGOpacitySource, + ) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 3usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn mStrokeDasharrayFromObject(&self) -> bool { + unsafe { ::std::mem::transmute(self._bitfield_2.get(6usize, 1u8) as u8) } + } + #[inline] + pub fn set_mStrokeDasharrayFromObject(&mut self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn mStrokeDasharrayFromObject_raw(this: *const Self) -> bool { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_2), 6usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_mStrokeDasharrayFromObject_raw(this: *mut Self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn mStrokeDashoffsetFromObject(&self) -> bool { + unsafe { ::std::mem::transmute(self._bitfield_2.get(7usize, 1u8) as u8) } + } + #[inline] + pub fn set_mStrokeDashoffsetFromObject(&mut self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn mStrokeDashoffsetFromObject_raw(this: *const Self) -> bool { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_2), 7usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_mStrokeDashoffsetFromObject_raw(this: *mut Self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn mStrokeWidthFromObject(&self) -> bool { + unsafe { ::std::mem::transmute(self._bitfield_2.get(8usize, 1u8) as u8) } + } + #[inline] + pub fn set_mStrokeWidthFromObject(&mut self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn mStrokeWidthFromObject_raw(this: *const Self) -> bool { + unsafe { + ::std::mem::transmute( + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_2), 8usize, 1u8) as u8, + ) + } + } + #[inline] + pub unsafe fn set_mStrokeWidthFromObject_raw(this: *mut Self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit< + [u8; 2usize], + >>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 8usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_2( + mFillOpacitySource: nsStyleSVGOpacitySource, + mStrokeOpacitySource: nsStyleSVGOpacitySource, + mStrokeDasharrayFromObject: bool, + mStrokeDashoffsetFromObject: bool, + mStrokeWidthFromObject: bool, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 3u8, + { + let mFillOpacitySource: u32 = unsafe { + ::std::mem::transmute(mFillOpacitySource) + }; + mFillOpacitySource as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 3usize, + 3u8, + { + let mStrokeOpacitySource: u32 = unsafe { + ::std::mem::transmute(mStrokeOpacitySource) + }; + mStrokeOpacitySource as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 6usize, + 1u8, + { + let mStrokeDasharrayFromObject: u8 = unsafe { + ::std::mem::transmute(mStrokeDasharrayFromObject) + }; + mStrokeDasharrayFromObject as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 7usize, + 1u8, + { + let mStrokeDashoffsetFromObject: u8 = unsafe { + ::std::mem::transmute(mStrokeDashoffsetFromObject) + }; + mStrokeDashoffsetFromObject as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 8usize, + 1u8, + { + let mStrokeWidthFromObject: u8 = unsafe { + ::std::mem::transmute(mStrokeWidthFromObject) + }; + mStrokeWidthFromObject as u64 + }, + ); + __bindgen_bitfield_unit + } +} diff --git a/bindgen-tests/tests/expectations/tests/what_is_going_on.rs b/bindgen-tests/tests/expectations/tests/what_is_going_on.rs new file mode 100644 index 0000000000..aaeab668e1 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/what_is_going_on.rs @@ -0,0 +1,29 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct UnknownUnits { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of UnknownUnits"][::std::mem::size_of::() - 1usize]; + ["Alignment of UnknownUnits"][::std::mem::align_of::() - 1usize]; +}; +pub type Float = f32; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct PointTyped { + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, + pub x: F, + pub y: F, +} +impl Default for PointTyped { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type IntPoint = PointTyped; diff --git a/bindgen-tests/tests/expectations/tests/win32-dtors.rs b/bindgen-tests/tests/expectations/tests/win32-dtors.rs new file mode 100644 index 0000000000..d7ed1290f8 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/win32-dtors.rs @@ -0,0 +1,145 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default)] +pub struct CppObj { + pub x: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of CppObj"][::std::mem::size_of::() - 4usize]; + ["Alignment of CppObj"][::std::mem::align_of::() - 4usize]; + ["Offset of field: CppObj::x"][::std::mem::offset_of!(CppObj, x) - 0usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}??0CppObj@@QEAA@H@Z"] + pub fn CppObj_CppObj(this: *mut CppObj, x: ::std::os::raw::c_int); +} +unsafe extern "C" { + #[link_name = "\u{1}??1CppObj@@QEAA@XZ"] + pub fn CppObj_CppObj_destructor(this: *mut CppObj); +} +impl CppObj { + #[inline] + pub unsafe fn new(x: ::std::os::raw::c_int) -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + CppObj_CppObj(__bindgen_tmp.as_mut_ptr(), x); + __bindgen_tmp.assume_init() + } + #[inline] + pub unsafe fn destruct(&mut self) { + CppObj_CppObj_destructor(self) + } +} +#[repr(C)] +pub struct CppObj2__bindgen_vtable(::std::os::raw::c_void); +#[repr(C)] +#[derive(Debug)] +pub struct CppObj2 { + pub vtable_: *const CppObj2__bindgen_vtable, + pub x: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of CppObj2"][::std::mem::size_of::() - 16usize]; + ["Alignment of CppObj2"][::std::mem::align_of::() - 8usize]; + ["Offset of field: CppObj2::x"][::std::mem::offset_of!(CppObj2, x) - 8usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}??0CppObj2@@QEAA@H@Z"] + pub fn CppObj2_CppObj2(this: *mut CppObj2, x: ::std::os::raw::c_int); +} +impl Default for CppObj2 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl CppObj2 { + #[inline] + pub unsafe fn new(x: ::std::os::raw::c_int) -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + CppObj2_CppObj2(__bindgen_tmp.as_mut_ptr(), x); + __bindgen_tmp.assume_init() + } +} +unsafe extern "C" { + #[link_name = "\u{1}??1CppObj2@@UEAA@XZ"] + pub fn CppObj2_CppObj2_destructor(this: *mut CppObj2); +} +#[repr(C)] +#[derive(Debug)] +pub struct CppObj3 { + pub _base: CppObj2, + pub x: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of CppObj3"][::std::mem::size_of::() - 24usize]; + ["Alignment of CppObj3"][::std::mem::align_of::() - 8usize]; + ["Offset of field: CppObj3::x"][::std::mem::offset_of!(CppObj3, x) - 16usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}??0CppObj3@@QEAA@H@Z"] + pub fn CppObj3_CppObj3(this: *mut CppObj3, x: ::std::os::raw::c_int); +} +impl Default for CppObj3 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl CppObj3 { + #[inline] + pub unsafe fn new(x: ::std::os::raw::c_int) -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + CppObj3_CppObj3(__bindgen_tmp.as_mut_ptr(), x); + __bindgen_tmp.assume_init() + } +} +unsafe extern "C" { + #[link_name = "\u{1}??1CppObj3@@UEAA@XZ"] + pub fn CppObj3_CppObj3_destructor(this: *mut CppObj3); +} +#[repr(C)] +#[derive(Debug)] +pub struct CppObj4 { + pub _base: CppObj2, + pub x: ::std::os::raw::c_int, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of CppObj4"][::std::mem::size_of::() - 24usize]; + ["Alignment of CppObj4"][::std::mem::align_of::() - 8usize]; + ["Offset of field: CppObj4::x"][::std::mem::offset_of!(CppObj4, x) - 16usize]; +}; +unsafe extern "C" { + #[link_name = "\u{1}??0CppObj4@@QEAA@H@Z"] + pub fn CppObj4_CppObj4(this: *mut CppObj4, x: ::std::os::raw::c_int); +} +impl Default for CppObj4 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl CppObj4 { + #[inline] + pub unsafe fn new(x: ::std::os::raw::c_int) -> Self { + let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit(); + CppObj4_CppObj4(__bindgen_tmp.as_mut_ptr(), x); + __bindgen_tmp.assume_init() + } +} +unsafe extern "C" { + #[link_name = "\u{1}??1CppObj4@@UEAA@XZ"] + pub fn CppObj4_CppObj4_destructor(this: *mut CppObj4); +} diff --git a/bindgen-tests/tests/expectations/tests/win32-thiscall.rs b/bindgen-tests/tests/expectations/tests/win32-thiscall.rs new file mode 100644 index 0000000000..aecdfbbf1f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/win32-thiscall.rs @@ -0,0 +1,33 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(not(test))] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "thiscall" { + #[link_name = "\u{1}?test@Foo@@QAEXXZ"] + pub fn Foo_test(this: *mut Foo); +} +unsafe extern "thiscall" { + #[link_name = "\u{1}?test2@Foo@@QAEHH@Z"] + pub fn Foo_test2( + this: *mut Foo, + var: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +impl Foo { + #[inline] + pub unsafe fn test(&mut self) { + Foo_test(self) + } + #[inline] + pub unsafe fn test2(&mut self, var: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + Foo_test2(self, var) + } +} diff --git a/bindgen-tests/tests/expectations/tests/win32-thiscall_1_73.rs b/bindgen-tests/tests/expectations/tests/win32-thiscall_1_73.rs new file mode 100644 index 0000000000..4741f029ff --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/win32-thiscall_1_73.rs @@ -0,0 +1,33 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target = "i686-pc-windows-msvc")] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +#[test] +fn bindgen_test_layout_Foo() { + assert_eq!(::std::mem::size_of::(), 1usize, "Size of Foo"); + assert_eq!(::std::mem::align_of::(), 1usize, "Alignment of Foo"); +} +extern "thiscall" { + #[link_name = "\u{1}?test@Foo@@QAEXXZ"] + pub fn Foo_test(this: *mut Foo); +} +extern "thiscall" { + #[link_name = "\u{1}?test2@Foo@@QAEHH@Z"] + pub fn Foo_test2( + this: *mut Foo, + var: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +impl Foo { + #[inline] + pub unsafe fn test(&mut self) { + Foo_test(self) + } + #[inline] + pub unsafe fn test2(&mut self, var: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + Foo_test2(self, var) + } +} diff --git a/bindgen-tests/tests/expectations/tests/win32-thiscall_nightly.rs b/bindgen-tests/tests/expectations/tests/win32-thiscall_nightly.rs new file mode 100644 index 0000000000..87b63574a9 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/win32-thiscall_nightly.rs @@ -0,0 +1,34 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(feature = "nightly")] +#![feature(abi_thiscall)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct Foo { + pub _address: u8, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Foo"][::std::mem::size_of::() - 1usize]; + ["Alignment of Foo"][::std::mem::align_of::() - 1usize]; +}; +unsafe extern "thiscall" { + #[link_name = "\u{1}?test@Foo@@QAEXXZ"] + pub fn Foo_test(this: *mut Foo); +} +unsafe extern "thiscall" { + #[link_name = "\u{1}?test2@Foo@@QAEHH@Z"] + pub fn Foo_test2( + this: *mut Foo, + var: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +impl Foo { + #[inline] + pub unsafe fn test(&mut self) { + Foo_test(self) + } + #[inline] + pub unsafe fn test2(&mut self, var: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + Foo_test2(self, var) + } +} diff --git a/bindgen-tests/tests/expectations/tests/win32-vectorcall-nightly.rs b/bindgen-tests/tests/expectations/tests/win32-vectorcall-nightly.rs new file mode 100644 index 0000000000..1c7b2fdbf6 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/win32-vectorcall-nightly.rs @@ -0,0 +1,10 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(feature = "nightly")] +#![feature(abi_vectorcall)] +unsafe extern "vectorcall" { + #[link_name = "\u{1}test_vectorcall@@16"] + pub fn test_vectorcall( + a: ::std::os::raw::c_int, + b: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} diff --git a/bindgen-tests/tests/expectations/tests/win32-vectorcall.rs b/bindgen-tests/tests/expectations/tests/win32-vectorcall.rs new file mode 100644 index 0000000000..fe64295a68 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/win32-vectorcall.rs @@ -0,0 +1 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] \ No newline at end of file diff --git a/bindgen-tests/tests/expectations/tests/with_array_pointers_arguments.rs b/bindgen-tests/tests/expectations/tests/with_array_pointers_arguments.rs new file mode 100644 index 0000000000..7cc1d65daf --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/with_array_pointers_arguments.rs @@ -0,0 +1,18 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn test_fn( + a: f32, + arr: *mut [::std::os::raw::c_int; 20usize], + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn test_fn2( + arr: *const [f32; 20usize], + b: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +pub type defArr = [::std::os::raw::c_char; 20usize]; +pub type foo = ::std::option::Option; +unsafe extern "C" { + pub fn bar(a: *mut defArr); +} diff --git a/bindgen-tests/tests/expectations/tests/without_array_pointers_arguments.rs b/bindgen-tests/tests/expectations/tests/without_array_pointers_arguments.rs new file mode 100644 index 0000000000..d642e84d27 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/without_array_pointers_arguments.rs @@ -0,0 +1,14 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + pub fn test_fn(a: f32, arr: *mut ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn test_fn2(arr: *const f32, b: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +pub type defArr = [::std::os::raw::c_char; 20usize]; +pub type foo = ::std::option::Option< + unsafe extern "C" fn(a: *mut ::std::os::raw::c_char), +>; +unsafe extern "C" { + pub fn bar(a: *mut ::std::os::raw::c_char); +} diff --git a/bindgen-tests/tests/expectations/tests/wrap-static-fns.rs b/bindgen-tests/tests/expectations/tests/wrap-static-fns.rs new file mode 100644 index 0000000000..bafcad8a7e --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/wrap-static-fns.rs @@ -0,0 +1,91 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +unsafe extern "C" { + #[link_name = "foo__extern"] + pub fn foo() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "bar__extern"] + pub fn bar() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "takes_ptr__extern"] + pub fn takes_ptr(arg: *mut ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "takes_fn_ptr__extern"] + pub fn takes_fn_ptr( + f: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "takes_fn__extern"] + pub fn takes_fn( + f: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +pub type func = ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, +>; +unsafe extern "C" { + #[link_name = "takes_alias__extern"] + pub fn takes_alias(f: func) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "takes_qualified__extern"] + pub fn takes_qualified( + arg: *const *const ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +pub const foo_BAR: foo = 0; +pub type foo = ::std::os::raw::c_uint; +unsafe extern "C" { + #[link_name = "takes_enum__extern"] + pub fn takes_enum(f: foo) -> foo; +} +unsafe extern "C" { + #[link_name = "nevermore__extern"] + pub fn nevermore(); +} +unsafe extern "C" { + #[link_name = "takes_fn_with_no_args__extern"] + pub fn takes_fn_with_no_args( + f: ::std::option::Option ::std::os::raw::c_int>, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "no_extra_argument__extern"] + pub fn no_extra_argument(va: *mut __va_list_tag); +} +unsafe extern "C" { + #[link_name = "many_va_list__extern"] + pub fn many_va_list( + i: ::std::os::raw::c_int, + va1: *mut __va_list_tag, + va2: *mut __va_list_tag, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "wrap_as_variadic_fn1__extern"] + pub fn wrap_as_variadic_fn1_wrapped( + i: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "wrap_as_variadic_fn2__extern"] + pub fn wrap_as_variadic_fn2_wrapped(i: ::std::os::raw::c_int, ...); +} +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, + _unused: [u8; 0], +} diff --git a/bindgen-tests/tests/expectations/tests/wrap_unsafe_ops_anon_union.rs b/bindgen-tests/tests/expectations/tests/wrap_unsafe_ops_anon_union.rs new file mode 100644 index 0000000000..94bddf4c25 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/wrap_unsafe_ops_anon_union.rs @@ -0,0 +1,57 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +pub struct TErrorResult { + pub mResult: ::std::os::raw::c_int, + pub __bindgen_anon_1: TErrorResult__bindgen_ty_1, + pub mMightHaveUnreported: bool, + pub mUnionState: TErrorResult_UnionState, +} +pub const TErrorResult_UnionState_HasMessage: TErrorResult_UnionState = 0; +pub const TErrorResult_UnionState_HasException: TErrorResult_UnionState = 0; +pub type TErrorResult_UnionState = i32; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct TErrorResult_Message { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct TErrorResult_DOMExceptionInfo { + _unused: [u8; 0], +} +#[repr(C)] +pub union TErrorResult__bindgen_ty_1 { + pub mMessage: *mut TErrorResult_Message, + pub mDOMExceptionInfo: *mut TErrorResult_DOMExceptionInfo, +} +impl Default for TErrorResult__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Default for TErrorResult { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +pub struct ErrorResult { + pub _base: TErrorResult, +} +impl Default for ErrorResult { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} diff --git a/bindgen-tests/tests/expectations/tests/wrap_unsafe_ops_class.rs b/bindgen-tests/tests/expectations/tests/wrap_unsafe_ops_class.rs new file mode 100644 index 0000000000..617a037631 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/wrap_unsafe_ops_class.rs @@ -0,0 +1,209 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Default)] +pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); +impl __IncompleteArrayField { + #[inline] + pub const fn new() -> Self { + __IncompleteArrayField(::std::marker::PhantomData, []) + } + #[inline] + pub fn as_ptr(&self) -> *const T { + self as *const _ as *const T + } + #[inline] + pub fn as_mut_ptr(&mut self) -> *mut T { + self as *mut _ as *mut T + } + #[inline] + pub unsafe fn as_slice(&self, len: usize) -> &[T] { + unsafe { ::std::slice::from_raw_parts(self.as_ptr(), len) } + } + #[inline] + pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { + unsafe { ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) } + } +} +impl ::std::fmt::Debug for __IncompleteArrayField { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + fmt.write_str("__IncompleteArrayField") + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct C { + pub a: ::std::os::raw::c_int, + pub big_array: [::std::os::raw::c_char; 33usize], +} +impl Default for C { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug)] +pub struct C_with_zero_length_array { + pub a: ::std::os::raw::c_int, + pub big_array: [::std::os::raw::c_char; 33usize], + pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>, +} +impl Default for C_with_zero_length_array { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default)] +pub struct C_with_zero_length_array_2 { + pub a: ::std::os::raw::c_int, + pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>, +} +#[repr(C)] +#[derive(Debug)] +pub struct C_with_incomplete_array { + pub a: ::std::os::raw::c_int, + pub big_array: [::std::os::raw::c_char; 33usize], + pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>, +} +impl Default for C_with_incomplete_array { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default)] +pub struct C_with_incomplete_array_2 { + pub a: ::std::os::raw::c_int, + pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>, +} +#[repr(C)] +#[derive(Debug)] +pub struct C_with_zero_length_array_and_incomplete_array { + pub a: ::std::os::raw::c_int, + pub big_array: [::std::os::raw::c_char; 33usize], + pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>, + pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>, +} +impl Default for C_with_zero_length_array_and_incomplete_array { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default)] +pub struct C_with_zero_length_array_and_incomplete_array_2 { + pub a: ::std::os::raw::c_int, + pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>, + pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>, +} +#[repr(C)] +#[derive(Debug, Default)] +pub struct WithDtor { + pub b: ::std::os::raw::c_int, +} +#[repr(C)] +#[derive(Debug)] +pub struct IncompleteArrayNonCopiable { + pub whatever: *mut ::std::os::raw::c_void, + pub incomplete_array: __IncompleteArrayField, +} +impl Default for IncompleteArrayNonCopiable { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Union { + pub d: f32, + pub i: ::std::os::raw::c_int, +} +impl Default for Union { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct WithUnion { + pub data: Union, +} +impl Default for WithUnion { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct RealAbstractionWithTonsOfMethods { + pub _address: u8, +} +unsafe extern "C" { + #[link_name = "\u{1}_ZNK32RealAbstractionWithTonsOfMethods3barEv"] + pub fn RealAbstractionWithTonsOfMethods_bar( + this: *const RealAbstractionWithTonsOfMethods, + ); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3barEv"] + pub fn RealAbstractionWithTonsOfMethods_bar1( + this: *mut RealAbstractionWithTonsOfMethods, + ); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3barEi"] + pub fn RealAbstractionWithTonsOfMethods_bar2( + this: *mut RealAbstractionWithTonsOfMethods, + foo: ::std::os::raw::c_int, + ); +} +unsafe extern "C" { + #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3staEv"] + pub fn RealAbstractionWithTonsOfMethods_sta(); +} +impl RealAbstractionWithTonsOfMethods { + #[inline] + pub unsafe fn bar(&self) { + unsafe { RealAbstractionWithTonsOfMethods_bar(self) } + } + #[inline] + pub unsafe fn bar1(&mut self) { + unsafe { RealAbstractionWithTonsOfMethods_bar1(self) } + } + #[inline] + pub unsafe fn bar2(&mut self, foo: ::std::os::raw::c_int) { + unsafe { RealAbstractionWithTonsOfMethods_bar2(self, foo) } + } + #[inline] + pub unsafe fn sta() { + unsafe { RealAbstractionWithTonsOfMethods_sta() } + } +} diff --git a/bindgen-tests/tests/expectations/tests/wrap_unsafe_ops_dynamic_loading_simple.rs b/bindgen-tests/tests/expectations/tests/wrap_unsafe_ops_dynamic_loading_simple.rs new file mode 100644 index 0000000000..05be5d9944 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/wrap_unsafe_ops_dynamic_loading_simple.rs @@ -0,0 +1,63 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub struct TestLib { + __library: ::libloading::Library, + pub foo: Result< + unsafe extern "C" fn( + x: ::std::os::raw::c_int, + y: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + ::libloading::Error, + >, + pub bar: Result< + unsafe extern "C" fn(x: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + ::libloading::Error, + >, + pub baz: Result< + unsafe extern "C" fn() -> ::std::os::raw::c_int, + ::libloading::Error, + >, + pub FLUX: Result<*mut ::std::os::raw::c_int, ::libloading::Error>, +} +impl TestLib { + pub unsafe fn new

(path: P) -> Result + where + P: AsRef<::std::ffi::OsStr>, + { + let library = unsafe { ::libloading::Library::new(path) }?; + unsafe { Self::from_library(library) } + } + pub unsafe fn from_library(library: L) -> Result + where + L: Into<::libloading::Library>, + { + let __library = library.into(); + let foo = unsafe { __library.get(b"foo\0") }.map(|sym| *sym); + let bar = unsafe { __library.get(b"bar\0") }.map(|sym| *sym); + let baz = unsafe { __library.get(b"baz\0") }.map(|sym| *sym); + let FLUX = unsafe { __library.get::<*mut ::std::os::raw::c_int>(b"FLUX\0") } + .map(|sym| *sym); + Ok(TestLib { + __library, + foo, + bar, + baz, + FLUX, + }) + } + pub unsafe fn foo( + &self, + x: ::std::os::raw::c_int, + y: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int { + unsafe { (self.foo.as_ref().expect("Expected function, got error."))(x, y) } + } + pub unsafe fn bar(&self, x: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int { + unsafe { (self.bar.as_ref().expect("Expected function, got error."))(x) } + } + pub unsafe fn baz(&self) -> ::std::os::raw::c_int { + unsafe { (self.baz.as_ref().expect("Expected function, got error."))() } + } + pub unsafe fn FLUX(&self) -> *mut ::std::os::raw::c_int { + *self.FLUX.as_ref().expect("Expected variable, got error.") + } +} diff --git a/bindgen-tests/tests/expectations/tests/wrap_unsafe_ops_objc_class.rs b/bindgen-tests/tests/expectations/tests/wrap_unsafe_ops_objc_class.rs new file mode 100644 index 0000000000..34252b10d3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/wrap_unsafe_ops_objc_class.rs @@ -0,0 +1,32 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#![cfg(target_os = "macos")] +use objc::{self, msg_send, sel, sel_impl, class}; +#[allow(non_camel_case_types)] +pub type id = *mut objc::runtime::Object; +unsafe extern "C" { + pub static mut fooVar: Foo; +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone)] +pub struct Foo(pub id); +impl std::ops::Deref for Foo { + type Target = objc::runtime::Object; + fn deref(&self) -> &Self::Target { + unsafe { &*self.0 } + } +} +unsafe impl objc::Message for Foo {} +impl Foo { + pub fn alloc() -> Self { + Self(unsafe { msg_send!(class!(Foo), alloc) }) + } +} +impl IFoo for Foo {} +pub trait IFoo: Sized + std::ops::Deref { + unsafe fn method(&self) + where + ::Target: objc::Message + Sized, + { + unsafe { msg_send!(* self, method) } + } +} diff --git a/bindgen-tests/tests/expectations/tests/zero-size-array-align.rs b/bindgen-tests/tests/expectations/tests/zero-size-array-align.rs new file mode 100644 index 0000000000..48fc0cb1d6 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/zero-size-array-align.rs @@ -0,0 +1,50 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Default)] +pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); +impl __IncompleteArrayField { + #[inline] + pub const fn new() -> Self { + __IncompleteArrayField(::std::marker::PhantomData, []) + } + #[inline] + pub fn as_ptr(&self) -> *const T { + self as *const _ as *const T + } + #[inline] + pub fn as_mut_ptr(&mut self) -> *mut T { + self as *mut _ as *mut T + } + #[inline] + pub unsafe fn as_slice(&self, len: usize) -> &[T] { + ::std::slice::from_raw_parts(self.as_ptr(), len) + } + #[inline] + pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { + ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) + } +} +impl ::std::fmt::Debug for __IncompleteArrayField { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + fmt.write_str("__IncompleteArrayField") + } +} +#[repr(C)] +#[derive(Debug, Default)] +pub struct dm_deps { + pub count: ::std::os::raw::c_uint, + pub filler: ::std::os::raw::c_uint, + pub device: __IncompleteArrayField<::std::os::raw::c_ulonglong>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of dm_deps"][::std::mem::size_of::() - 8usize]; + ["Alignment of dm_deps"][::std::mem::align_of::() - 8usize]; + ["Offset of field: dm_deps::count"][::std::mem::offset_of!(dm_deps, count) - 0usize]; + [ + "Offset of field: dm_deps::filler", + ][::std::mem::offset_of!(dm_deps, filler) - 4usize]; + [ + "Offset of field: dm_deps::device", + ][::std::mem::offset_of!(dm_deps, device) - 8usize]; +}; diff --git a/bindgen-tests/tests/expectations/tests/zero-sized-array.rs b/bindgen-tests/tests/expectations/tests/zero-sized-array.rs new file mode 100644 index 0000000000..229a6ee4db --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/zero-sized-array.rs @@ -0,0 +1,115 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Default)] +pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); +impl __IncompleteArrayField { + #[inline] + pub const fn new() -> Self { + __IncompleteArrayField(::std::marker::PhantomData, []) + } + #[inline] + pub fn as_ptr(&self) -> *const T { + self as *const _ as *const T + } + #[inline] + pub fn as_mut_ptr(&mut self) -> *mut T { + self as *mut _ as *mut T + } + #[inline] + pub unsafe fn as_slice(&self, len: usize) -> &[T] { + ::std::slice::from_raw_parts(self.as_ptr(), len) + } + #[inline] + pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { + ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) + } +} +impl ::std::fmt::Debug for __IncompleteArrayField { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + fmt.write_str("__IncompleteArrayField") + } +} +/// Bizarrely enough, this should *not* get an `_address` field. +#[repr(C)] +#[derive(Debug, Default)] +pub struct ZeroSizedArray { + pub arr: __IncompleteArrayField<::std::os::raw::c_char>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of ZeroSizedArray"][::std::mem::size_of::() - 0usize]; + ["Alignment of ZeroSizedArray"][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: ZeroSizedArray::arr", + ][::std::mem::offset_of!(ZeroSizedArray, arr) - 0usize]; +}; +/// And nor should this get an `_address` field. +#[repr(C)] +#[derive(Debug, Default)] +pub struct ContainsZeroSizedArray { + pub zsa: ZeroSizedArray, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of ContainsZeroSizedArray", + ][::std::mem::size_of::() - 0usize]; + [ + "Alignment of ContainsZeroSizedArray", + ][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: ContainsZeroSizedArray::zsa", + ][::std::mem::offset_of!(ContainsZeroSizedArray, zsa) - 0usize]; +}; +/** Inheriting from ZeroSizedArray shouldn't cause an `_address` to be inserted + either.*/ +#[repr(C)] +#[derive(Debug, Default)] +pub struct InheritsZeroSizedArray { + pub _base: ZeroSizedArray, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of InheritsZeroSizedArray", + ][::std::mem::size_of::() - 0usize]; + [ + "Alignment of InheritsZeroSizedArray", + ][::std::mem::align_of::() - 1usize]; +}; +/// And this should not get an `_address` field either. +#[repr(C)] +#[derive(Debug, Default)] +pub struct DynamicallySizedArray { + pub arr: __IncompleteArrayField<::std::os::raw::c_char>, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of DynamicallySizedArray", + ][::std::mem::size_of::() - 0usize]; + [ + "Alignment of DynamicallySizedArray", + ][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: DynamicallySizedArray::arr", + ][::std::mem::offset_of!(DynamicallySizedArray, arr) - 0usize]; +}; +/// No `_address` field here either. +#[repr(C)] +#[derive(Debug, Default)] +pub struct ContainsDynamicallySizedArray { + pub dsa: DynamicallySizedArray, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + [ + "Size of ContainsDynamicallySizedArray", + ][::std::mem::size_of::() - 0usize]; + [ + "Alignment of ContainsDynamicallySizedArray", + ][::std::mem::align_of::() - 1usize]; + [ + "Offset of field: ContainsDynamicallySizedArray::dsa", + ][::std::mem::offset_of!(ContainsDynamicallySizedArray, dsa) - 0usize]; +}; diff --git a/bindgen-tests/tests/headers/16-byte-alignment.h b/bindgen-tests/tests/headers/16-byte-alignment.h new file mode 100644 index 0000000000..235a994abe --- /dev/null +++ b/bindgen-tests/tests/headers/16-byte-alignment.h @@ -0,0 +1,34 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq + +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; + +struct rte_ipv4_tuple { + uint32_t src_addr; + uint32_t dst_addr; + union { + struct { + uint16_t dport; + uint16_t sport; + }; + uint32_t sctp_tag; + }; +}; + +struct rte_ipv6_tuple { + uint8_t src_addr[16]; + uint8_t dst_addr[16]; + union { + struct { + uint16_t dport; + uint16_t sport; + }; + uint32_t sctp_tag; + }; +}; + +union rte_thash_tuple { + struct rte_ipv4_tuple v4; + struct rte_ipv6_tuple v6; +} __attribute__((aligned(16))); diff --git a/bindgen-tests/tests/headers/381-decltype-alias.hpp b/bindgen-tests/tests/headers/381-decltype-alias.hpp new file mode 100644 index 0000000000..0bec2fc7d1 --- /dev/null +++ b/bindgen-tests/tests/headers/381-decltype-alias.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: -- -std=c++11 + +namespace std { + template struct allocator_traits { + typedef decltype ( _S_size_type_helper ( ( _Alloc * ) 0 ) ) __size_type; + }; +} diff --git a/bindgen-tests/tests/headers/abi-override.h b/bindgen-tests/tests/headers/abi-override.h new file mode 100644 index 0000000000..0b0fdcf245 --- /dev/null +++ b/bindgen-tests/tests/headers/abi-override.h @@ -0,0 +1,9 @@ +// bindgen-flags: --override-abi=foo=fastcall --override-abi=bar=stdcall --override-abi=boo=efiapi --override-abi=foobar=efiapi --override-abi qux=system --raw-line '#![cfg(target = "i686-pc-windows-msvc")]' + +void foo(); +void bar(); +void baz(); +void qux(); + +typedef void (*boo)(); +typedef void (*foobar)(boo boo); diff --git a/bindgen-tests/tests/headers/abi_variadic_function.hpp b/bindgen-tests/tests/headers/abi_variadic_function.hpp new file mode 100644 index 0000000000..2141535c7a --- /dev/null +++ b/bindgen-tests/tests/headers/abi_variadic_function.hpp @@ -0,0 +1,4 @@ +// bindgen-flags: -- -std=c++11 + +char __attribute__((ms_abi)) a(char, ...); +char b(char, ...); diff --git a/tests/headers/accessors.hpp b/bindgen-tests/tests/headers/accessors.hpp similarity index 100% rename from tests/headers/accessors.hpp rename to bindgen-tests/tests/headers/accessors.hpp diff --git a/bindgen-tests/tests/headers/alias_comments.h b/bindgen-tests/tests/headers/alias_comments.h new file mode 100644 index 0000000000..2547c3c1a2 --- /dev/null +++ b/bindgen-tests/tests/headers/alias_comments.h @@ -0,0 +1,26 @@ +// bindgen-flags: --no-layout-tests + +/** + * This is Struct + */ +typedef struct { + /** + * This is field + */ + int field; +} Struct; + +/** + * This is AliasToStruct + */ +typedef Struct AliasToStruct; + +/** + * This is AliasToInt + */ +typedef int AliasToInt; + +/** + * This is AliasToAliasToInt + */ +typedef AliasToInt AliasToAliasToInt; diff --git a/bindgen-tests/tests/headers/allowlist-file.hpp b/bindgen-tests/tests/headers/allowlist-file.hpp new file mode 100644 index 0000000000..b0354a047f --- /dev/null +++ b/bindgen-tests/tests/headers/allowlist-file.hpp @@ -0,0 +1,21 @@ +// bindgen-flags: --allowlist-file ".*/allowlisted/file.*" --allowlist-type AllowlistMe -- -Itests/headers + + +// Forward declaration of struct that's defined in an allowlisted file. +struct StructWithAllowlistedDefinition; + +#include "allowlisted/file.hpp" + +// Actual definition of struct that has a forward declaration in an allowlisted file. +struct StructWithAllowlistedFwdDecl { + int b; +}; + +class Ignored { + char c; +}; + +// Also have an explicitly allowlisted type +class AllowlistMe { + int foo; +}; diff --git a/bindgen-tests/tests/headers/allowlist-namespaces-basic.hpp b/bindgen-tests/tests/headers/allowlist-namespaces-basic.hpp new file mode 100644 index 0000000000..fb4dd1be37 --- /dev/null +++ b/bindgen-tests/tests/headers/allowlist-namespaces-basic.hpp @@ -0,0 +1,10 @@ +// bindgen-flags: --enable-cxx-namespaces --allowlist-type outer::inner::Helper + +namespace outer { + namespace inner { + struct Helper {}; + } + struct Test { + inner::Helper helper; + }; +} diff --git a/bindgen-tests/tests/headers/allowlist-namespaces.hpp b/bindgen-tests/tests/headers/allowlist-namespaces.hpp new file mode 100644 index 0000000000..2cffe9d3dd --- /dev/null +++ b/bindgen-tests/tests/headers/allowlist-namespaces.hpp @@ -0,0 +1,10 @@ +// bindgen-flags: --enable-cxx-namespaces --allowlist-type '.*' + +namespace outer { + namespace inner { + struct Helper {}; + } + struct Test { + inner::Helper helper; + }; +} diff --git a/bindgen-tests/tests/headers/allowlist_basic.hpp b/bindgen-tests/tests/headers/allowlist_basic.hpp new file mode 100644 index 0000000000..ef858c95da --- /dev/null +++ b/bindgen-tests/tests/headers/allowlist_basic.hpp @@ -0,0 +1,16 @@ +// bindgen-flags: --allowlist-type AllowlistMe + +template +class AllowlistMe { + class Inner { + T bar; + }; + + int foo; + Inner bar; +}; + +struct DontAllowlistMe { + void* foo; + double _Complex noComplexGenerated; +}; diff --git a/bindgen-tests/tests/headers/allowlist_fix.hpp b/bindgen-tests/tests/headers/allowlist_fix.hpp new file mode 100644 index 0000000000..ff810fc6e0 --- /dev/null +++ b/bindgen-tests/tests/headers/allowlist_fix.hpp @@ -0,0 +1,4 @@ +// bindgen-flags: --allowlist-function 'Servo_.*' --blocklist-type Test --raw-line "pub enum Test {}" + +struct Test {}; +extern "C" void Servo_Test(Test* a); diff --git a/bindgen-tests/tests/headers/allowlist_item.h b/bindgen-tests/tests/headers/allowlist_item.h new file mode 100644 index 0000000000..7e5e00d0e3 --- /dev/null +++ b/bindgen-tests/tests/headers/allowlist_item.h @@ -0,0 +1,17 @@ +// bindgen-flags: --allowlist-item 'Foo.*' + +struct Foo { + int field; +}; + +struct Foo FooNew(int value); + +#define FooDefault 0 + +struct Bar { + int field; +}; + +struct Foo BarNew(int value); + +#define BarDefault 0 diff --git a/tests/headers/whitelist_vars.h b/bindgen-tests/tests/headers/allowlist_vars.h similarity index 100% rename from tests/headers/whitelist_vars.h rename to bindgen-tests/tests/headers/allowlist_vars.h diff --git a/bindgen-tests/tests/headers/allowlist_warnings.h b/bindgen-tests/tests/headers/allowlist_warnings.h new file mode 100644 index 0000000000..83c9e259f0 --- /dev/null +++ b/bindgen-tests/tests/headers/allowlist_warnings.h @@ -0,0 +1,2 @@ +// bindgen-flags: --allowlist-function "doesnt_match_anything" +int non_matched_function(int arg); diff --git a/bindgen-tests/tests/headers/allowlisted-item-references-no-hash.hpp b/bindgen-tests/tests/headers/allowlisted-item-references-no-hash.hpp new file mode 100644 index 0000000000..56c2a39fba --- /dev/null +++ b/bindgen-tests/tests/headers/allowlisted-item-references-no-hash.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --with-derive-hash --allowlist-type "AllowlistMe" --no-hash "NoHash" + +struct NoHash {}; + +class AllowlistMe { + NoHash a; +}; diff --git a/bindgen-tests/tests/headers/allowlisted-item-references-no-partialeq.hpp b/bindgen-tests/tests/headers/allowlisted-item-references-no-partialeq.hpp new file mode 100644 index 0000000000..d85fb6b754 --- /dev/null +++ b/bindgen-tests/tests/headers/allowlisted-item-references-no-partialeq.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --with-derive-partialeq --allowlist-type "AllowlistMe" --no-partialeq "NoPartialEq" + +struct NoPartialEq {}; + +class AllowlistMe { + NoPartialEq a; +}; diff --git a/bindgen-tests/tests/headers/allowlisted/file.hpp b/bindgen-tests/tests/headers/allowlisted/file.hpp new file mode 100644 index 0000000000..5f360e5ea9 --- /dev/null +++ b/bindgen-tests/tests/headers/allowlisted/file.hpp @@ -0,0 +1,22 @@ +void SomeFunction(); +extern int someVar; +#define SOME_DEFUN 123 + +class someClass { + void somePrivateMethod(); +public: + void somePublicMethod(int foo); +}; + +extern "C" void ExternFunction(); + +namespace foo { + void NamespacedFunction(); +} + + +struct StructWithAllowlistedFwdDecl; + +struct StructWithAllowlistedDefinition { + StructWithAllowlistedFwdDecl* other; +}; diff --git a/bindgen-tests/tests/headers/allowlisted_item_references_no_copy.hpp b/bindgen-tests/tests/headers/allowlisted_item_references_no_copy.hpp new file mode 100644 index 0000000000..9feb30549a --- /dev/null +++ b/bindgen-tests/tests/headers/allowlisted_item_references_no_copy.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --allowlist-type "AllowlistMe" --no-copy "NoCopy" + +struct NoCopy {}; + +class AllowlistMe { + NoCopy a; +}; diff --git a/tests/headers/annotation_hide.hpp b/bindgen-tests/tests/headers/annotation_hide.hpp similarity index 100% rename from tests/headers/annotation_hide.hpp rename to bindgen-tests/tests/headers/annotation_hide.hpp diff --git a/bindgen-tests/tests/headers/anon-fields-prefix.h b/bindgen-tests/tests/headers/anon-fields-prefix.h new file mode 100644 index 0000000000..8dcae0c61a --- /dev/null +++ b/bindgen-tests/tests/headers/anon-fields-prefix.h @@ -0,0 +1,15 @@ +// bindgen-flags: --anon-fields-prefix "u" + +union color { + struct { + unsigned char r; + unsigned char g; + unsigned char b; + }; + struct { + unsigned char y; + unsigned char u; + unsigned char v; + }; + unsigned char v3[3]; +}; diff --git a/bindgen-tests/tests/headers/anon_enum.hpp b/bindgen-tests/tests/headers/anon_enum.hpp new file mode 100644 index 0000000000..bbd52240a7 --- /dev/null +++ b/bindgen-tests/tests/headers/anon_enum.hpp @@ -0,0 +1,11 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*" +struct Test { + int foo; + float bar; + enum { T_NONE }; +}; + +typedef enum { + Foo, + Bar, +} Baz; diff --git a/bindgen-tests/tests/headers/anon_enum_allowlist.h b/bindgen-tests/tests/headers/anon_enum_allowlist.h new file mode 100644 index 0000000000..94119a8773 --- /dev/null +++ b/bindgen-tests/tests/headers/anon_enum_allowlist.h @@ -0,0 +1,6 @@ +// bindgen-flags: --allowlist-var "NODE_.*" --rustified-enum ".*" + +enum { + NODE_FLAG_FOO, + NODE_FLAG_BAR, +}; diff --git a/bindgen-tests/tests/headers/anon_enum_allowlist_item.h b/bindgen-tests/tests/headers/anon_enum_allowlist_item.h new file mode 100644 index 0000000000..23caacc9a1 --- /dev/null +++ b/bindgen-tests/tests/headers/anon_enum_allowlist_item.h @@ -0,0 +1,6 @@ +// bindgen-flags: --allowlist-item "NODE_.*" + +enum { + NODE_FLAG_FOO, + NODE_FLAG_BAR, +}; diff --git a/bindgen-tests/tests/headers/anon_enum_blocklist.h b/bindgen-tests/tests/headers/anon_enum_blocklist.h new file mode 100644 index 0000000000..61aa6e680c --- /dev/null +++ b/bindgen-tests/tests/headers/anon_enum_blocklist.h @@ -0,0 +1,11 @@ +// bindgen-flags: --blocklist-type "_bindgen_ty_1" + +enum { + FLAG_X, + FLAG_Y, +}; + +enum { + FLAG_Z, + FLAG_W, +}; diff --git a/bindgen-tests/tests/headers/anon_enum_trait.hpp b/bindgen-tests/tests/headers/anon_enum_trait.hpp new file mode 100644 index 0000000000..cc0cd3898c --- /dev/null +++ b/bindgen-tests/tests/headers/anon_enum_trait.hpp @@ -0,0 +1,23 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*" + +template +class DataType { +public: + typedef _Tp value_type; + typedef value_type work_type; + typedef value_type channel_type; + typedef value_type vec_type; + enum { generic_type = 1, + depth = -1, + channels = 1, + fmt = 0, + type = -1, + }; +}; + +struct Foo { + enum { + Bar = 0, + Baz = 0, + }; +}; diff --git a/bindgen-tests/tests/headers/anon_struct_in_union.h b/bindgen-tests/tests/headers/anon_struct_in_union.h new file mode 100644 index 0000000000..2587ede54a --- /dev/null +++ b/bindgen-tests/tests/headers/anon_struct_in_union.h @@ -0,0 +1,8 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +struct s { + union { + struct inner { + int b; + } field; + } u; +}; diff --git a/tests/headers/anon_union.hpp b/bindgen-tests/tests/headers/anon_union.hpp similarity index 77% rename from tests/headers/anon_union.hpp rename to bindgen-tests/tests/headers/anon_union.hpp index 126f6a6ee3..e4be25bcab 100644 --- a/tests/headers/anon_union.hpp +++ b/bindgen-tests/tests/headers/anon_union.hpp @@ -1,3 +1,4 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*" template struct TErrorResult { enum UnionState { diff --git a/bindgen-tests/tests/headers/anonymous-template-types.hpp b/bindgen-tests/tests/headers/anonymous-template-types.hpp new file mode 100644 index 0000000000..d4ad534b2b --- /dev/null +++ b/bindgen-tests/tests/headers/anonymous-template-types.hpp @@ -0,0 +1,24 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++14 + +template +struct Foo { + T t_member; +}; + +template +struct Bar { + char member; +}; + +template +struct Quux { + V v_member; +}; + +template +struct Lobo { + char also_member; +}; + +template +using AliasWithAnonType = char; diff --git a/bindgen-tests/tests/headers/arg_keyword.hpp b/bindgen-tests/tests/headers/arg_keyword.hpp new file mode 100644 index 0000000000..283fcf2306 --- /dev/null +++ b/bindgen-tests/tests/headers/arg_keyword.hpp @@ -0,0 +1,3 @@ +// This comment exists to ensure that `--dump-preprocessed-input` doesn't strip +// comments. +void foo(const char* type); diff --git a/bindgen-tests/tests/headers/array-of-zero-sized-types.hpp b/bindgen-tests/tests/headers/array-of-zero-sized-types.hpp new file mode 100644 index 0000000000..87b36d415c --- /dev/null +++ b/bindgen-tests/tests/headers/array-of-zero-sized-types.hpp @@ -0,0 +1,12 @@ +/** + * This should get an `_address` byte. + */ +struct Empty {}; + +/** + * This should not get an `_address` byte, since each `Empty` gets one, meaning + * that this object is addressable. + */ +struct HasArrayOfEmpty { + Empty empties[10]; +}; diff --git a/bindgen-tests/tests/headers/atomic-constant.h b/bindgen-tests/tests/headers/atomic-constant.h new file mode 100644 index 0000000000..b28f76f7e4 --- /dev/null +++ b/bindgen-tests/tests/headers/atomic-constant.h @@ -0,0 +1,2 @@ +_Atomic(int) a; +int b; diff --git a/bindgen-tests/tests/headers/attribute-custom-cli.h b/bindgen-tests/tests/headers/attribute-custom-cli.h new file mode 100644 index 0000000000..a5f73c78e5 --- /dev/null +++ b/bindgen-tests/tests/headers/attribute-custom-cli.h @@ -0,0 +1,14 @@ +// bindgen-flags: --default-enum-style rust --default-non-copy-union-style manually_drop --no-default=".*" --no-hash=".*" --no-partialeq=".*" --no-debug=".*" --no-copy=".*" --with-attribute-custom="foo_[^e].*=#[doc(hidden)]" --with-attribute-custom-struct="foo.*=#[derive(Default)]" --with-attribute-custom-enum="foo.*=#[cfg_attr(test, derive(PartialOrd, Copy))]" --with-attribute-custom-union="foo.*=#[derive(Clone)],#[derive(Copy)]" +struct foo_struct { + int inner; +}; +enum foo_enum { + inner = 0 +}; +union foo_union { + int fst; + float snd; +}; +struct non_matching { + int inner; +}; diff --git a/bindgen-tests/tests/headers/attribute-custom.h b/bindgen-tests/tests/headers/attribute-custom.h new file mode 100644 index 0000000000..dd382bf8cd --- /dev/null +++ b/bindgen-tests/tests/headers/attribute-custom.h @@ -0,0 +1,28 @@ +// bindgen-flags: --no-derive-debug --no-derive-copy --no-derive-default --default-enum-style rust --no-layout-tests + +/**

*/ +struct my_type; + +/**
*/ +struct my_type; + +struct my_type { + int a; +}; + +/** + *
+ *
+ */ +struct my_type2; + +struct my_type2 { + unsigned a; +}; + +/** + *
+ */ +struct my_type3 { + unsigned long a; +}; diff --git a/bindgen-tests/tests/headers/attribute_warn_unused_result.hpp b/bindgen-tests/tests/headers/attribute_warn_unused_result.hpp new file mode 100644 index 0000000000..bb9c3687e9 --- /dev/null +++ b/bindgen-tests/tests/headers/attribute_warn_unused_result.hpp @@ -0,0 +1,10 @@ +// bindgen-flags: --enable-function-attribute-detection + +class Foo { +public: + __attribute__((warn_unused_result)) + int foo(int); +}; + +__attribute__((warn_unused_result)) +int foo(int); diff --git a/bindgen-tests/tests/headers/attribute_warn_unused_result_no_attribute_detection.hpp b/bindgen-tests/tests/headers/attribute_warn_unused_result_no_attribute_detection.hpp new file mode 100644 index 0000000000..25127d9cd0 --- /dev/null +++ b/bindgen-tests/tests/headers/attribute_warn_unused_result_no_attribute_detection.hpp @@ -0,0 +1,8 @@ +class Foo { +public: + __attribute__((warn_unused_result)) + int foo(int); +}; + +__attribute__((warn_unused_result)) +int foo(int); diff --git a/bindgen-tests/tests/headers/auto.hpp b/bindgen-tests/tests/headers/auto.hpp new file mode 100644 index 0000000000..b5f6d5f360 --- /dev/null +++ b/bindgen-tests/tests/headers/auto.hpp @@ -0,0 +1,19 @@ +// bindgen-flags: -- -std=c++14 +// bindgen-unstable + +class Foo { + static constexpr auto kFoo = 2 == 2; +}; + +template +class Bar { + static const constexpr auto kBar = T(1); +}; + +template auto Test1() { + return T(1); +} + +auto Test2() { + return Test1(); +} diff --git a/bindgen-tests/tests/headers/bad-namespace-parenthood-inheritance.hpp b/bindgen-tests/tests/headers/bad-namespace-parenthood-inheritance.hpp new file mode 100644 index 0000000000..ce21a40158 --- /dev/null +++ b/bindgen-tests/tests/headers/bad-namespace-parenthood-inheritance.hpp @@ -0,0 +1,15 @@ +namespace std +{ + template < typename > struct char_traits; +} +namespace __gnu_cxx +{ + template < typename > struct char_traits; +} +namespace std +{ + template < class _CharT > struct char_traits:__gnu_cxx::char_traits < + _CharT > + { + }; +} diff --git a/bindgen-tests/tests/headers/base-to-derived.hpp b/bindgen-tests/tests/headers/base-to-derived.hpp new file mode 100644 index 0000000000..ea31e0f258 --- /dev/null +++ b/bindgen-tests/tests/headers/base-to-derived.hpp @@ -0,0 +1,19 @@ +// bindgen-flags: -- -std=c++11 + +struct false_type {}; + +template +struct __is_base_to_derived_ref; + +template +struct __is_base_to_derived_ref<_From, _To, true> +{ + typedef _To type; + + static constexpr bool value = type::value; +}; + +template +struct __is_base_to_derived_ref<_From, _To, false> +: public false_type +{ }; diff --git a/bindgen-tests/tests/headers/bindgen-union-inside-namespace.hpp b/bindgen-tests/tests/headers/bindgen-union-inside-namespace.hpp new file mode 100644 index 0000000000..4007e02566 --- /dev/null +++ b/bindgen-tests/tests/headers/bindgen-union-inside-namespace.hpp @@ -0,0 +1,8 @@ +// bindgen-flags: --enable-cxx-namespaces + +namespace foo { + union Bar { + int foo; + int bar; + }; +} diff --git a/bindgen-tests/tests/headers/bitfield-32bit-overflow.h b/bindgen-tests/tests/headers/bitfield-32bit-overflow.h new file mode 100644 index 0000000000..907969960d --- /dev/null +++ b/bindgen-tests/tests/headers/bitfield-32bit-overflow.h @@ -0,0 +1,36 @@ + +struct MuchBitfield { + char m0 : 1; + char m1 : 1; + char m2 : 1; + char m3 : 1; + char m4 : 1; + char m5 : 1; + char m6 : 1; + char m7 : 1; + char m8 : 1; + char m9 : 1; + char m10 : 1; + char m11 : 1; + char m12 : 1; + char m13 : 1; + char m14 : 1; + char m15 : 1; + char m16 : 1; + char m17 : 1; + char m18 : 1; + char m19 : 1; + char m20 : 1; + char m21 : 1; + char m22 : 1; + char m23 : 1; + char m24 : 1; + char m25 : 1; + char m26 : 1; + char m27 : 1; + char m28 : 1; + char m29 : 1; + char m30 : 1; + char m31 : 1; + char m32 : 1; +}; diff --git a/bindgen-tests/tests/headers/bitfield-enum-basic.hpp b/bindgen-tests/tests/headers/bitfield-enum-basic.hpp new file mode 100644 index 0000000000..339fb4d554 --- /dev/null +++ b/bindgen-tests/tests/headers/bitfield-enum-basic.hpp @@ -0,0 +1,27 @@ +// bindgen-flags: --bitfield-enum "Foo|Buz|NS_.*|DUMMY_.*" --rustified-enum ".*" -- -std=c++11 + +enum Foo { + Bar = 1 << 1, + Baz = 1 << 2, + Duplicated = 1 << 2, + Negative = -3, +}; + +enum class Buz : signed char { + Bar = 1 << 1, + Baz = 1 << 2, + Duplicated = 1 << 2, + Negative = -3, +}; + +enum { + NS_FOO = 1 << 0, + NS_BAR = 1 << 1, +}; + +class Dummy { + enum { + DUMMY_FOO = 1 << 0, + DUMMY_BAR = 1 << 1, + }; +}; diff --git a/bindgen-tests/tests/headers/bitfield-enum-repr-c.hpp b/bindgen-tests/tests/headers/bitfield-enum-repr-c.hpp new file mode 100644 index 0000000000..da5fc961dd --- /dev/null +++ b/bindgen-tests/tests/headers/bitfield-enum-repr-c.hpp @@ -0,0 +1,8 @@ +// bindgen-flags: --bitfield-enum "Foo" -- -std=c++11 + +enum Foo { + Bar = 1 << 1, + Baz = 1 << 2, + Duplicated = 1 << 2, + Negative = -3, +}; diff --git a/bindgen-tests/tests/headers/bitfield-enum-repr-transparent.hpp b/bindgen-tests/tests/headers/bitfield-enum-repr-transparent.hpp new file mode 100644 index 0000000000..1c58ff4eca --- /dev/null +++ b/bindgen-tests/tests/headers/bitfield-enum-repr-transparent.hpp @@ -0,0 +1,8 @@ +// bindgen-flags: --bitfield-enum "Foo" + +enum Foo { + Bar = 1 << 1, + Baz = 1 << 2, + Duplicated = 1 << 2, + Negative = -3, +}; diff --git a/bindgen-tests/tests/headers/bitfield-large.hpp b/bindgen-tests/tests/headers/bitfield-large.hpp new file mode 100644 index 0000000000..2e34927929 --- /dev/null +++ b/bindgen-tests/tests/headers/bitfield-large.hpp @@ -0,0 +1,9 @@ +struct HasBigBitfield { + __int128 x : 128; +}; + + +struct HasTwoBigBitfields { + __int128 x : 80; + __int128 y : 48; +}; diff --git a/bindgen-tests/tests/headers/bitfield-linux-32.hpp b/bindgen-tests/tests/headers/bitfield-linux-32.hpp new file mode 100644 index 0000000000..71ee6a7e1d --- /dev/null +++ b/bindgen-tests/tests/headers/bitfield-linux-32.hpp @@ -0,0 +1,9 @@ +// bindgen-flags: --no-layout-tests -- --target=i586-unknown-linux + +typedef unsigned long long uint64_t; + +struct Test { + uint64_t foo; + uint64_t x : 56; + uint64_t y : 8; +}; diff --git a/bindgen-tests/tests/headers/bitfield-method-same-name.hpp b/bindgen-tests/tests/headers/bitfield-method-same-name.hpp new file mode 100644 index 0000000000..d66f16c0ec --- /dev/null +++ b/bindgen-tests/tests/headers/bitfield-method-same-name.hpp @@ -0,0 +1,6 @@ +struct Foo { + char type_ : 3; + char type(); + void set_type_(char c); + void set_type(char c); +}; diff --git a/bindgen-tests/tests/headers/bitfield-template.hpp b/bindgen-tests/tests/headers/bitfield-template.hpp new file mode 100644 index 0000000000..664199b9c0 --- /dev/null +++ b/bindgen-tests/tests/headers/bitfield-template.hpp @@ -0,0 +1,4 @@ +template struct foo { + T member; + bool b : 8; +}; diff --git a/bindgen-tests/tests/headers/bitfield_align.h b/bindgen-tests/tests/headers/bitfield_align.h new file mode 100644 index 0000000000..7b9527a2ec --- /dev/null +++ b/bindgen-tests/tests/headers/bitfield_align.h @@ -0,0 +1,49 @@ +struct A { + unsigned char x; + unsigned b1 : 1; + unsigned b2 : 1; + unsigned b3 : 1; + unsigned b4 : 1; + unsigned b5 : 1; + unsigned b6 : 1; + unsigned b7 : 1; + unsigned b8 : 1; + unsigned b9 : 1; + unsigned b10 : 1; + unsigned char y; +}; + +struct B { + unsigned foo : 31; + unsigned char bar : 1; +}; + +struct C { + unsigned char x; + unsigned b1 : 1; + unsigned b2 : 1; + unsigned baz; +}; + +struct Date1 { + unsigned short nWeekDay : 3; // 0..7 (3 bits) + unsigned short nMonthDay : 6; // 0..31 (6 bits) + unsigned short nMonth : 5; // 0..12 (5 bits) + unsigned short nYear : 8; // 0..100 (8 bits) +}; + +struct Date2 { + unsigned short nWeekDay : 3; // 0..7 (3 bits) + unsigned short nMonthDay : 6; // 0..31 (6 bits) + unsigned short nMonth : 5; // 0..12 (5 bits) + unsigned short nYear : 8; // 0..100 (8 bits) + unsigned char byte : 8; +}; + +struct Date3 { + unsigned short nWeekDay : 3; // 0..7 (3 bits) + unsigned short nMonthDay : 6; // 0..31 (6 bits) + unsigned short nMonth : 5; // 0..12 (5 bits) + unsigned short nYear : 8; // 0..100 (8 bits) + unsigned char byte; +}; diff --git a/bindgen-tests/tests/headers/bitfield_align_2.h b/bindgen-tests/tests/headers/bitfield_align_2.h new file mode 100644 index 0000000000..cb0f2e20d2 --- /dev/null +++ b/bindgen-tests/tests/headers/bitfield_align_2.h @@ -0,0 +1,12 @@ +// bindgen-flags: --rustified-enum ".*" --raw-line '#![cfg(not(target_os="windows"))]' +enum MyEnum { + ONE, + TWO, + THREE, + FOUR +}; + +struct TaggedPtr { + enum MyEnum tag : 2; + long ptr : 62; +}; diff --git a/bindgen-tests/tests/headers/bitfield_large_overflow.hpp b/bindgen-tests/tests/headers/bitfield_large_overflow.hpp new file mode 100644 index 0000000000..9e040ae336 --- /dev/null +++ b/bindgen-tests/tests/headers/bitfield_large_overflow.hpp @@ -0,0 +1,3 @@ +struct { + unsigned : 632; +} a; diff --git a/bindgen-tests/tests/headers/bitfield_method_mangling.h b/bindgen-tests/tests/headers/bitfield_method_mangling.h new file mode 100644 index 0000000000..257648ee78 --- /dev/null +++ b/bindgen-tests/tests/headers/bitfield_method_mangling.h @@ -0,0 +1,5 @@ +typedef struct +{ + unsigned int pad3: 24; + unsigned int type: 8; +} mach_msg_type_descriptor_t; diff --git a/bindgen-tests/tests/headers/bitfield_pack_offset.h b/bindgen-tests/tests/headers/bitfield_pack_offset.h new file mode 100644 index 0000000000..5118a64642 --- /dev/null +++ b/bindgen-tests/tests/headers/bitfield_pack_offset.h @@ -0,0 +1,21 @@ +struct A { + const unsigned char name[7]; /* 0 7 */ + unsigned char firmness:4; /* 7: 0 1 */ + unsigned char color:4; /* 7: 4 1 */ + unsigned short weedsBonus:3; /* 8: 0 2 */ + unsigned short pestsBonus:3; /* 8: 3 2 */ + unsigned short size:10; /* 8: 6 2 */ + unsigned char maxYield; /* 10 1 */ + unsigned char minYield:4; /* 11: 0 1 */ + unsigned char waterBonus:4; /* 11: 4 1 */ + + /* XXX 4 bytes hole, try to pack */ + + const unsigned char * description1; /* 16 8 */ + + /* size: 24, cachelines: 1, members: 10 */ + /* sum members: 16, holes: 1, sum holes: 4 */ + /* sum bitfield members: 32 bits (4 bytes) */ + /* last cacheline: 24 bytes */ +}; + diff --git a/bindgen-tests/tests/headers/bitfield_pragma_packed.h b/bindgen-tests/tests/headers/bitfield_pragma_packed.h new file mode 100644 index 0000000000..c18b80ddfc --- /dev/null +++ b/bindgen-tests/tests/headers/bitfield_pragma_packed.h @@ -0,0 +1,20 @@ +#pragma pack(push, 1) +struct Struct { + unsigned char a : 1; + unsigned char b : 1; + unsigned char c : 6; + unsigned short int d : 16; + unsigned char e : 8; +}; +#pragma pack(pop) + +struct Inner { + unsigned short a: 16; + unsigned short b: 16; +}; + +#pragma pack(push, 1) +struct Outer { + struct Inner inner; +}; +#pragma pop diff --git a/bindgen-tests/tests/headers/block_return_type.h b/bindgen-tests/tests/headers/block_return_type.h new file mode 100644 index 0000000000..be76cb5956 --- /dev/null +++ b/bindgen-tests/tests/headers/block_return_type.h @@ -0,0 +1,4 @@ +// bindgen-flags: --generate-block --block-extern-crate -- -fblocks +// bindgen-osx-only + +int (^func(void))(int, int); diff --git a/bindgen-tests/tests/headers/blocklist-and-impl-debug.hpp b/bindgen-tests/tests/headers/blocklist-and-impl-debug.hpp new file mode 100644 index 0000000000..14e17537e1 --- /dev/null +++ b/bindgen-tests/tests/headers/blocklist-and-impl-debug.hpp @@ -0,0 +1,10 @@ +// bindgen-flags: --impl-debug --blocklist-type BlocklistMe --raw-line 'pub struct BlocklistMe(u8);' + +struct BlocklistMe {}; + +/** + * Because this type contains a blocklisted type, it should not derive Debug. + */ +struct ShouldManuallyImplDebug { + BlocklistMe a; +}; diff --git a/bindgen-tests/tests/headers/blocklist-file.hpp b/bindgen-tests/tests/headers/blocklist-file.hpp new file mode 100644 index 0000000000..ad8bcd665c --- /dev/null +++ b/bindgen-tests/tests/headers/blocklist-file.hpp @@ -0,0 +1,18 @@ +// bindgen-flags: --blocklist-file ".*/blocklisted/file.*" -- -Itests/headers + +// Forward declaration of struct that's defined in a blocklisted file. +struct StructWithBlocklistedDefinition; + +#include "blocklisted/file.hpp" +#include "blocklisted/fake-stdint.h" + +struct SizedIntegers { + uint8_t x; + uint16_t y; + uint32_t z; +}; + +// Actual definition of struct that has a forward declaration in a blocklisted file. +struct StructWithBlocklistedFwdDecl { + uint8_t b; +}; diff --git a/bindgen-tests/tests/headers/blocklist-function.hpp b/bindgen-tests/tests/headers/blocklist-function.hpp new file mode 100644 index 0000000000..d7c8bb35d7 --- /dev/null +++ b/bindgen-tests/tests/headers/blocklist-function.hpp @@ -0,0 +1,16 @@ +// bindgen-flags: --blocklist-function "ExternFunction" --blocklist-function "foo::NamespacedFunction" --blocklist-function "C_ClassMethod" --enable-cxx-namespaces + +extern "C" void ExternFunction(); + +namespace foo { + void NamespacedFunction(); +} + +namespace bar { + void NamespacedFunction(); +} + +class C { +public: + void ClassMethod(); +}; diff --git a/bindgen-tests/tests/headers/blocklist-item.hpp b/bindgen-tests/tests/headers/blocklist-item.hpp new file mode 100644 index 0000000000..2d795d5a5a --- /dev/null +++ b/bindgen-tests/tests/headers/blocklist-item.hpp @@ -0,0 +1,21 @@ +// bindgen-flags: --blocklist-item "SomeFunction" --blocklist-item "SOME_DEFUN" --blocklist-item "someVar" --blocklist-item "ExternFunction" --blocklist-item "foo::NamespacedFunction" --blocklist-item "someClass.*" --enable-cxx-namespaces + +void SomeFunction(); +extern int someVar; +#define SOME_DEFUN 123 + +class someClass { + void somePrivateMethod(); +public: + void somePublicMethod(int foo); +}; + +extern "C" void ExternFunction(); + +namespace foo { + void NamespacedFunction(); +} + +namespace bar { + void NamespacedFunction(); +} diff --git a/bindgen-tests/tests/headers/blocklist-methods.hpp b/bindgen-tests/tests/headers/blocklist-methods.hpp new file mode 100644 index 0000000000..4be21b945e --- /dev/null +++ b/bindgen-tests/tests/headers/blocklist-methods.hpp @@ -0,0 +1,8 @@ +// bindgen-flags: --blocklist-function="Foo_ba.*" + +class Foo { + public: + int foo(); + int bar(); + int baz(); +}; diff --git a/bindgen-tests/tests/headers/blocklist-var.hpp b/bindgen-tests/tests/headers/blocklist-var.hpp new file mode 100644 index 0000000000..3c70e6f032 --- /dev/null +++ b/bindgen-tests/tests/headers/blocklist-var.hpp @@ -0,0 +1,3 @@ +// bindgen-flags: --blocklist-var should_be_blocked + +extern int should_be_blocked; diff --git a/bindgen-tests/tests/headers/blocklist_bitfield_unit.h b/bindgen-tests/tests/headers/blocklist_bitfield_unit.h new file mode 100644 index 0000000000..5f7d94ced9 --- /dev/null +++ b/bindgen-tests/tests/headers/blocklist_bitfield_unit.h @@ -0,0 +1,7 @@ +// bindgen-flags: --blocklist-type "__BindgenBitfieldUnit" --raw-line '#[path = "./struct_with_bitfields.rs"] mod bitfields;' --raw-line 'use bitfields::*;' +struct C { + unsigned char x; + unsigned b1 : 1; + unsigned b2 : 1; + unsigned baz; +}; diff --git a/bindgen-tests/tests/headers/blocklisted/fake-stdint.h b/bindgen-tests/tests/headers/blocklisted/fake-stdint.h new file mode 100644 index 0000000000..a8cfe01056 --- /dev/null +++ b/bindgen-tests/tests/headers/blocklisted/fake-stdint.h @@ -0,0 +1,7 @@ +// -like types get special treatment even when blocklisted. +typedef signed char int8_t; +typedef unsigned char uint8_t; +typedef signed short int16_t; +typedef unsigned short uint16_t; +typedef signed int int32_t; +typedef unsigned int uint32_t; diff --git a/bindgen-tests/tests/headers/blocklisted/file.hpp b/bindgen-tests/tests/headers/blocklisted/file.hpp new file mode 100644 index 0000000000..4bcb589e1d --- /dev/null +++ b/bindgen-tests/tests/headers/blocklisted/file.hpp @@ -0,0 +1,26 @@ +void SomeFunction(); +extern int someVar; +#define SOME_DEFUN 123 + +class someClass { + void somePrivateMethod(); +public: + void somePublicMethod(int foo); +}; + +extern "C" void ExternFunction(); + +namespace foo { + void NamespacedFunction(); +} + +namespace bar { + void NamespacedFunction(); +} + + +struct StructWithBlocklistedFwdDecl; + +struct StructWithBlocklistedDefinition { + StructWithBlocklistedFwdDecl* other; +}; diff --git a/bindgen-tests/tests/headers/blocks-signature.hpp b/bindgen-tests/tests/headers/blocks-signature.hpp new file mode 100644 index 0000000000..eaa72526c2 --- /dev/null +++ b/bindgen-tests/tests/headers/blocks-signature.hpp @@ -0,0 +1,4 @@ +// bindgen-flags: --generate-block --block-extern-crate -- -fblocks +// bindgen-osx-only + +#include "blocks.hpp" diff --git a/bindgen-tests/tests/headers/blocks.hpp b/bindgen-tests/tests/headers/blocks.hpp new file mode 100644 index 0000000000..a68de7e2cc --- /dev/null +++ b/bindgen-tests/tests/headers/blocks.hpp @@ -0,0 +1,25 @@ +// bindgen-flags: --block-extern-crate -- -fblocks +// bindgen-osx-only + +typedef unsigned long long size_t; + +void atexit_b(void (^)(void)); + +typedef void *dispatch_data_t; + +typedef bool (^dispatch_data_applier_t)(dispatch_data_t region, + size_t offset, + const void *buffer, + size_t size); + +bool dispatch_data_apply(dispatch_data_t data, + dispatch_data_applier_t applier); + +bool foo(void (^)(size_t bar)); + +bool foo_ptr(void (^*)(size_t bar)); + +struct contains_block_pointers { + void (^val)(int); + void (^*ptr_val)(int); +}; diff --git a/bindgen-tests/tests/headers/bug-1529681.hpp b/bindgen-tests/tests/headers/bug-1529681.hpp new file mode 100644 index 0000000000..17fa849a15 --- /dev/null +++ b/bindgen-tests/tests/headers/bug-1529681.hpp @@ -0,0 +1,8 @@ +// bindgen-flags: -- -std=c++14 +// +// https://bugzilla.mozilla.org/show_bug.cgi?id=1529681 +// https://bugs.llvm.org/show_bug.cgi?id=40813 + +class BrowsingContext { + auto Tie(void* aUnused) const; +}; diff --git a/bindgen-tests/tests/headers/builtin-template.hpp b/bindgen-tests/tests/headers/builtin-template.hpp new file mode 100644 index 0000000000..4e64ebc779 --- /dev/null +++ b/bindgen-tests/tests/headers/builtin-template.hpp @@ -0,0 +1,6 @@ +namespace std { +template +class integer_sequence; +template +using make_integer_sequence = __make_integer_seq; +} diff --git a/bindgen-tests/tests/headers/c-empty-layout.h b/bindgen-tests/tests/headers/c-empty-layout.h new file mode 100644 index 0000000000..1fe02e8978 --- /dev/null +++ b/bindgen-tests/tests/headers/c-empty-layout.h @@ -0,0 +1 @@ +struct Foo {}; diff --git a/bindgen-tests/tests/headers/c-unwind-abi-override.h b/bindgen-tests/tests/headers/c-unwind-abi-override.h new file mode 100644 index 0000000000..591f4b84ff --- /dev/null +++ b/bindgen-tests/tests/headers/c-unwind-abi-override.h @@ -0,0 +1,5 @@ +// bindgen-flags: --override-abi="foo|bar=C-unwind" + +void foo(); +void bar(); +void baz(); diff --git a/bindgen-tests/tests/headers/c_naming.h b/bindgen-tests/tests/headers/c_naming.h new file mode 100644 index 0000000000..fd84c271fa --- /dev/null +++ b/bindgen-tests/tests/headers/c_naming.h @@ -0,0 +1,19 @@ +// bindgen-flags: --c-naming + +typedef const struct a { + int a; +} *a; + +union b { + int a; + int b; +}; +typedef union b b; + +enum c { + A, +}; + +void takes_a(a arg) {} +void takes_b(b arg) {} +void takes_c(enum c arg) {} diff --git a/bindgen-tests/tests/headers/call-conv-field.h b/bindgen-tests/tests/headers/call-conv-field.h new file mode 100644 index 0000000000..da45ba1d74 --- /dev/null +++ b/bindgen-tests/tests/headers/call-conv-field.h @@ -0,0 +1,13 @@ +// bindgen-flags: --raw-line "#![cfg(not(test))]" -- --target=i686-pc-win32 +// bindgen-unstable +// +// We can only check that this builds, but not that it actually passes, because +// we have no CI on the target platform. + +struct JNINativeInterface_ { + int (__stdcall *GetVersion)(void *env); + unsigned long long __hack; // A hack so the field alignment is the same than + // for 64-bit, where we run CI. +}; + +__stdcall void bar(); diff --git a/bindgen-tests/tests/headers/call-conv-typedef.h b/bindgen-tests/tests/headers/call-conv-typedef.h new file mode 100644 index 0000000000..3b911ddae5 --- /dev/null +++ b/bindgen-tests/tests/headers/call-conv-typedef.h @@ -0,0 +1,5 @@ +// bindgen-flags: --raw-line "#![cfg(not(test))]" -- --target=i686-pc-win32 + + +typedef void (__stdcall *void_fn)(); +typedef void_fn (__stdcall *fn)(int id); diff --git a/bindgen-tests/tests/headers/canonical-types.hpp b/bindgen-tests/tests/headers/canonical-types.hpp new file mode 100644 index 0000000000..c8eadd7e5e --- /dev/null +++ b/bindgen-tests/tests/headers/canonical-types.hpp @@ -0,0 +1,51 @@ +// bindgen-flags: -- -std=c++14 + +// Issue #2078. To pick up the definition of `ClassCInnerA`, +// `ty.canonical_type().declaration().definition()` is needed. + +template +class ClassA { +public: + class ClassAInner { + public: + T *x; + }; +}; + +template +class ClassB { +public: + void foo() { + ((D *)0)->quux(); + } +}; + +template +class ClassC { + struct ClassCInnerA; + + struct ClassCInnerB { + ClassCInnerA *cache; + }; + static_assert(sizeof(ClassCInnerB) > 0, ""); + + struct ClassCInnerA { + ClassCInnerB *member; + }; + +public: + class ClassCInnerCRTP : public ClassB::ClassAInner> { + public: + void quux() { + ((typename ClassA::ClassAInner *)0)->x->member; + } + }; +}; + +class ClassD : public ClassB::ClassCInnerCRTP> { +public: + void bar() { + ((ClassC::ClassCInnerCRTP *)0)->foo(); + } +}; + diff --git a/bindgen-tests/tests/headers/canonical_path_without_namespacing.hpp b/bindgen-tests/tests/headers/canonical_path_without_namespacing.hpp new file mode 100644 index 0000000000..92e8584284 --- /dev/null +++ b/bindgen-tests/tests/headers/canonical_path_without_namespacing.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --disable-name-namespacing + +namespace foo { + struct Bar {}; +} + +void baz(foo::Bar*); diff --git a/bindgen-tests/tests/headers/char.h b/bindgen-tests/tests/headers/char.h new file mode 100644 index 0000000000..7cffd865c0 --- /dev/null +++ b/bindgen-tests/tests/headers/char.h @@ -0,0 +1,21 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +typedef char Char; +typedef signed char SChar; +typedef unsigned char UChar; + +struct Test { + char ch; + unsigned char u; + signed char d; + const char cch; + const unsigned char cu; + const signed char cd; + + Char Cch; + UChar Cu; + SChar Cd; + const Char Ccch; + const UChar Ccu; + const SChar Ccd; +}; diff --git a/bindgen-tests/tests/headers/char16_t.hpp b/bindgen-tests/tests/headers/char16_t.hpp new file mode 100644 index 0000000000..35e1f16dd3 --- /dev/null +++ b/bindgen-tests/tests/headers/char16_t.hpp @@ -0,0 +1,4 @@ +// bindgen-flags: --use-distinct-char16-t --raw-line '#[repr(transparent)] pub struct bindgen_cchar16_t(u16);' -- -x c++ -std=c++14 + +void receive_char16_t(char16_t input) { +} diff --git a/bindgen-tests/tests/headers/class.hpp b/bindgen-tests/tests/headers/class.hpp new file mode 100644 index 0000000000..f77ac92a66 --- /dev/null +++ b/bindgen-tests/tests/headers/class.hpp @@ -0,0 +1,74 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --with-derive-partialord --with-derive-ord +// +class C { + int a; + // More than rust limits (32) + char big_array[33]; +}; + +class C_with_zero_length_array { + int a; + // More than rust limits (32) + char big_array[33]; + char zero_length_array[0]; +}; + +class C_with_zero_length_array_2 { + int a; + char zero_length_array[0]; +}; + +class C_with_incomplete_array { + int a; + // More than rust limits (32) + char big_array[33]; + char incomplete_array[]; +}; + +class C_with_incomplete_array_2 { + int a; + char incomplete_array[]; +}; + +class C_with_zero_length_array_and_incomplete_array { + int a; + // More than rust limits (32) + char big_array[33]; + char zero_length_array[0]; + char incomplete_array[]; +}; + +class C_with_zero_length_array_and_incomplete_array_2 { + int a; + char zero_length_array[0]; + char incomplete_array[]; +}; + +class WithDtor { + int b; + + ~WithDtor() {} +}; + +class IncompleteArrayNonCopiable { + void* whatever; + C incomplete_array[]; +}; + +union Union { + float d; + int i; +}; + +class WithUnion { + Union data; +}; + +class RealAbstractionWithTonsOfMethods { + void foo(); +public: + void bar() const; + void bar(); + void bar(int foo); + static void sta(); +}; diff --git a/bindgen-tests/tests/headers/class_nested.hpp b/bindgen-tests/tests/headers/class_nested.hpp new file mode 100644 index 0000000000..d6ca02c20a --- /dev/null +++ b/bindgen-tests/tests/headers/class_nested.hpp @@ -0,0 +1,37 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +class A { +public: + int member_a; + class B { + int member_b; + }; + + class C; + + template + class D { + T foo; + }; +}; + +class A::C { + int baz; +}; + +A::B var; +A::D baz; + +class D { + A::B member; +}; + +template +class Templated { + T member; + + class Templated_inner { + public: + T* member_ptr; + void get(); + }; +}; diff --git a/tests/headers/class_no_members.hpp b/bindgen-tests/tests/headers/class_no_members.hpp similarity index 81% rename from tests/headers/class_no_members.hpp rename to bindgen-tests/tests/headers/class_no_members.hpp index a448355866..6963e372d3 100644 --- a/tests/headers/class_no_members.hpp +++ b/bindgen-tests/tests/headers/class_no_members.hpp @@ -1,3 +1,4 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq // bindgen-flags: -- -std=c++11 class whatever { diff --git a/bindgen-tests/tests/headers/class_static.hpp b/bindgen-tests/tests/headers/class_static.hpp new file mode 100644 index 0000000000..d8f9be6d3f --- /dev/null +++ b/bindgen-tests/tests/headers/class_static.hpp @@ -0,0 +1,8 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +class MyClass { +public: + static const int* example; + static const int* example_check_no_collision; +}; + +static const int* example_check_no_collision; diff --git a/bindgen-tests/tests/headers/class_static_const.hpp b/bindgen-tests/tests/headers/class_static_const.hpp new file mode 100644 index 0000000000..3e320edcbe --- /dev/null +++ b/bindgen-tests/tests/headers/class_static_const.hpp @@ -0,0 +1,9 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +using int32_t = int; +typedef unsigned int uint32_t; + +class A { + static const int a = 0; + static const int32_t b = 077; + static const uint32_t c = 0xff; +}; diff --git a/bindgen-tests/tests/headers/class_use_as.hpp b/bindgen-tests/tests/headers/class_use_as.hpp new file mode 100644 index 0000000000..b7eaf29bd7 --- /dev/null +++ b/bindgen-tests/tests/headers/class_use_as.hpp @@ -0,0 +1,16 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq + +/** + *
+ */ +struct whatever_replacement { + int replacement; +}; + +struct whatever { + int b; +}; + +struct container { + whatever c; +}; diff --git a/bindgen-tests/tests/headers/class_with_dtor.hpp b/bindgen-tests/tests/headers/class_with_dtor.hpp new file mode 100644 index 0000000000..f52858a7b4 --- /dev/null +++ b/bindgen-tests/tests/headers/class_with_dtor.hpp @@ -0,0 +1,14 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq + + +template +class HandleWithDtor { + T* ptr; + ~HandleWithDtor() {} +}; + +typedef HandleWithDtor HandleValue; + +class WithoutDtor { + HandleValue shouldBeWithDtor; +}; diff --git a/bindgen-tests/tests/headers/class_with_enum.hpp b/bindgen-tests/tests/headers/class_with_enum.hpp new file mode 100644 index 0000000000..ebbc2c4049 --- /dev/null +++ b/bindgen-tests/tests/headers/class_with_enum.hpp @@ -0,0 +1,7 @@ +class A { +public: + enum B { + B1, + B2, + }; +}; \ No newline at end of file diff --git a/tests/headers/class_with_inner_struct.hpp b/bindgen-tests/tests/headers/class_with_inner_struct.hpp similarity index 89% rename from tests/headers/class_with_inner_struct.hpp rename to bindgen-tests/tests/headers/class_with_inner_struct.hpp index ec729fe66c..fd195fb789 100644 --- a/tests/headers/class_with_inner_struct.hpp +++ b/bindgen-tests/tests/headers/class_with_inner_struct.hpp @@ -1,3 +1,4 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*" // bindgen-flags: -- -std=c++11 class A { diff --git a/bindgen-tests/tests/headers/class_with_typedef.hpp b/bindgen-tests/tests/headers/class_with_typedef.hpp new file mode 100644 index 0000000000..7c3d3c97c1 --- /dev/null +++ b/bindgen-tests/tests/headers/class_with_typedef.hpp @@ -0,0 +1,23 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +typedef int AnotherInt; + +class C { +public: + typedef int MyInt; + typedef const char* Lookup; + MyInt c; + MyInt* ptr; + MyInt arr[10]; + AnotherInt d; + AnotherInt* other_ptr; + + void method(MyInt c); + void methodRef(MyInt& c); + void complexMethodRef(Lookup& c); + void anotherMethod(AnotherInt c); +}; + +class D: public C { +public: + MyInt* ptr; +}; diff --git a/bindgen-tests/tests/headers/comment-indent.hpp b/bindgen-tests/tests/headers/comment-indent.hpp new file mode 100644 index 0000000000..96c13fccb6 --- /dev/null +++ b/bindgen-tests/tests/headers/comment-indent.hpp @@ -0,0 +1,47 @@ +// bindgen-flags: --enable-cxx-namespaces + +/** + * This is a multi-line doc comment. + * + * This class is really really interesting, look! + */ +class Foo { + /** + * This nested class is also a multi-line doc comment. + * + * This class is not so interesting, but worth a bit of docs too! + */ + class Bar { }; +}; + +namespace test { + /** + * I'm in a namespace, and thus I may be on a rust module, most of the time. + * My documentation is pretty extensive, I guess. + */ + class Baz { + /** + * This member is plain awesome, just amazing. + * + * It also has super-extensive docs, with even a nice ascii-art diagram. + * + * +------+ +-------+ + * | foo | ----> | bar | + * +------+ +-------+ + */ + int member; + }; + + inline namespace foobiedoobie { + /** + * I'm in an inline namespace, and as such I shouldn't get generated inside + * a rust module, except when the relevant option is specified. Also, this + * comment shouldn't be misaligned. + */ + class InInlineNS { + }; + } + + /**/ + class Bazz {}; +} diff --git a/bindgen-tests/tests/headers/complex.h b/bindgen-tests/tests/headers/complex.h new file mode 100644 index 0000000000..2996be1feb --- /dev/null +++ b/bindgen-tests/tests/headers/complex.h @@ -0,0 +1,17 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq + +#define COMPLEX_TEST(ty_, name_) \ + struct Test##name_ { \ + ty_ _Complex mMember; \ + \ + }; \ + struct Test##name_##Ptr { \ + ty_ _Complex* mMember; \ + }; + +COMPLEX_TEST(double, Double) +COMPLEX_TEST(float, Float) + +// FIXME: 128-byte-aligned in some machines +// which we can't support right now in Rust. +// COMPLEX_TEST(long double, LongDouble) diff --git a/bindgen-tests/tests/headers/complex_global.h b/bindgen-tests/tests/headers/complex_global.h new file mode 100644 index 0000000000..6b9ffa53a1 --- /dev/null +++ b/bindgen-tests/tests/headers/complex_global.h @@ -0,0 +1,4 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +float _Complex globalValueFloat; +double _Complex globalValueDouble; +long double _Complex globalValueLongDouble; diff --git a/bindgen-tests/tests/headers/const-const-mut-ptr.h b/bindgen-tests/tests/headers/const-const-mut-ptr.h new file mode 100644 index 0000000000..cc7daf7c1e --- /dev/null +++ b/bindgen-tests/tests/headers/const-const-mut-ptr.h @@ -0,0 +1,3 @@ +struct foo { + const int** const* const* bar; +}; diff --git a/bindgen-tests/tests/headers/const_array.h b/bindgen-tests/tests/headers/const_array.h new file mode 100644 index 0000000000..a337881f52 --- /dev/null +++ b/bindgen-tests/tests/headers/const_array.h @@ -0,0 +1,2 @@ +extern const int foo[1]; +extern int bar[1]; diff --git a/bindgen-tests/tests/headers/const_array_fn_arg.h b/bindgen-tests/tests/headers/const_array_fn_arg.h new file mode 100644 index 0000000000..ebe2286137 --- /dev/null +++ b/bindgen-tests/tests/headers/const_array_fn_arg.h @@ -0,0 +1 @@ +void f(const int a[]); diff --git a/bindgen-tests/tests/headers/const_array_typedef.h b/bindgen-tests/tests/headers/const_array_typedef.h new file mode 100644 index 0000000000..e5379c97ba --- /dev/null +++ b/bindgen-tests/tests/headers/const_array_typedef.h @@ -0,0 +1,13 @@ +typedef struct { + int field; +} strct; + +typedef strct typ[1]; + +extern typ w; +extern strct *x; + +extern const typ y; +extern const strct *z; + +void function(const typ a, const strct *b); diff --git a/bindgen-tests/tests/headers/const_bool.hpp b/bindgen-tests/tests/headers/const_bool.hpp new file mode 100644 index 0000000000..633a7c9077 --- /dev/null +++ b/bindgen-tests/tests/headers/const_bool.hpp @@ -0,0 +1,9 @@ +// bindgen-unstable + +const bool k = true; +struct A { + static const bool k = false; +}; + +typedef bool foo; +const foo k2 = true; diff --git a/bindgen-tests/tests/headers/const_enum_unnamed.hpp b/bindgen-tests/tests/headers/const_enum_unnamed.hpp new file mode 100644 index 0000000000..cee87e6464 --- /dev/null +++ b/bindgen-tests/tests/headers/const_enum_unnamed.hpp @@ -0,0 +1,10 @@ +// bindgen-flags: --rustified-enum ".*" + +enum { + FOO_BAR, + FOO_BAZ, +}; + +class Foo { + enum { FOO_BAR = 10 }; +}; diff --git a/bindgen-tests/tests/headers/const_multidim_array_fn_arg.h b/bindgen-tests/tests/headers/const_multidim_array_fn_arg.h new file mode 100644 index 0000000000..784a51fe80 --- /dev/null +++ b/bindgen-tests/tests/headers/const_multidim_array_fn_arg.h @@ -0,0 +1 @@ +void f(const int a[1][1]); diff --git a/tests/headers/const_ptr.hpp b/bindgen-tests/tests/headers/const_ptr.hpp similarity index 100% rename from tests/headers/const_ptr.hpp rename to bindgen-tests/tests/headers/const_ptr.hpp diff --git a/tests/headers/const_resolved_ty.h b/bindgen-tests/tests/headers/const_resolved_ty.h similarity index 100% rename from tests/headers/const_resolved_ty.h rename to bindgen-tests/tests/headers/const_resolved_ty.h diff --git a/tests/headers/const_tparam.hpp b/bindgen-tests/tests/headers/const_tparam.hpp similarity index 100% rename from tests/headers/const_tparam.hpp rename to bindgen-tests/tests/headers/const_tparam.hpp diff --git a/bindgen-tests/tests/headers/constant-evaluate.h b/bindgen-tests/tests/headers/constant-evaluate.h new file mode 100644 index 0000000000..812553ed3e --- /dev/null +++ b/bindgen-tests/tests/headers/constant-evaluate.h @@ -0,0 +1,21 @@ +// bindgen-unstable +// bindgen-flags: --rustified-enum ".*" + +enum { + foo = 4, + bar = 8, +}; + +typedef unsigned long long EasyToOverflow; +const EasyToOverflow k = 0x80000000; + +const EasyToOverflow k_expr = 1ULL << 60; +const EasyToOverflow wow = 1ULL << 31; + +const long long BAZ = (1 << foo) | bar; +const double fuzz = (1 + 50.0f); +const char BAZZ = '5'; +const char WAT = '\0'; + +const char* bytestring = "Foo"; +const char* NOT_UTF8 = "\xf0\x28\x8c\x28"; diff --git a/bindgen-tests/tests/headers/constant-non-specialized-tp.hpp b/bindgen-tests/tests/headers/constant-non-specialized-tp.hpp new file mode 100644 index 0000000000..539c28870b --- /dev/null +++ b/bindgen-tests/tests/headers/constant-non-specialized-tp.hpp @@ -0,0 +1,15 @@ +// bindgen-flags: -- -std=c++11 + +// This test ensure we protect ourselves from an LLVM crash. + +template +struct Test { + static constexpr bool x[] = {Args::x...}; +}; + +template +struct Outer { + struct Inner { + static constexpr int value[] = { T::value... }; + }; +}; diff --git a/bindgen-tests/tests/headers/constified-enum-module-overflow.hpp b/bindgen-tests/tests/headers/constified-enum-module-overflow.hpp new file mode 100644 index 0000000000..d48f2be1b2 --- /dev/null +++ b/bindgen-tests/tests/headers/constified-enum-module-overflow.hpp @@ -0,0 +1,8 @@ +template class B{}; +template class C { +public: + using U = B; +}; +class A : C { + U u; +}; diff --git a/bindgen-tests/tests/headers/constify-all-enums.h b/bindgen-tests/tests/headers/constify-all-enums.h new file mode 100644 index 0000000000..6f4364e3cc --- /dev/null +++ b/bindgen-tests/tests/headers/constify-all-enums.h @@ -0,0 +1,10 @@ + +enum foo { + THIS, + SHOULD_BE, + A_CONSTANT, +}; + +struct bar { + enum foo this_should_work; +}; diff --git a/bindgen-tests/tests/headers/constify-enum.h b/bindgen-tests/tests/headers/constify-enum.h new file mode 100644 index 0000000000..b8e0be3ee7 --- /dev/null +++ b/bindgen-tests/tests/headers/constify-enum.h @@ -0,0 +1,14 @@ +// bindgen-flags: --rustified-enum ".*" + +enum nsCSSPropertyID { + eCSSProperty_a, + eCSSProperty_b, + + eCSSProperty_COUNT, /**<
*/ + eCSSProperty_COUNT_DUMMY2 = eCSSProperty_COUNT - 1, /**<
*/ + + eCSSPropertyAlias_aa, + eCSSPropertyAlias_bb, + + eCSSProperty_COUNT_unexistingVariantValue, /**<
*/ +}; diff --git a/bindgen-tests/tests/headers/constify-module-enums-basic.h b/bindgen-tests/tests/headers/constify-module-enums-basic.h new file mode 100644 index 0000000000..631e884743 --- /dev/null +++ b/bindgen-tests/tests/headers/constify-module-enums-basic.h @@ -0,0 +1,17 @@ +// bindgen-flags: --constified-enum-module foo + +enum foo { + THIS, + SHOULD_BE, + A_CONSTANT, +}; + +typedef enum foo foo_alias1; +typedef foo_alias1 foo_alias2; + +struct bar { + enum foo this_should_work; +}; + +enum foo *func1(enum foo arg1, enum foo *arg2, enum foo **arg3); +foo_alias1 *func2(foo_alias1 arg1, foo_alias1 *arg2, foo_alias1 **arg3); \ No newline at end of file diff --git a/bindgen-tests/tests/headers/constify-module-enums-namespace.hpp b/bindgen-tests/tests/headers/constify-module-enums-namespace.hpp new file mode 100644 index 0000000000..5d8ea23a52 --- /dev/null +++ b/bindgen-tests/tests/headers/constify-module-enums-namespace.hpp @@ -0,0 +1,17 @@ +// bindgen-flags: --enable-cxx-namespaces --constified-enum-module ns1::ns2::foo + +namespace ns1 { + namespace ns2 { + enum foo { + THIS, + SHOULD_BE, + A_CONSTANT, + }; + } + + namespace ns3 { + struct bar { + enum ns2::foo this_should_work; + }; + } +} \ No newline at end of file diff --git a/bindgen-tests/tests/headers/constify-module-enums-shadow-name.h b/bindgen-tests/tests/headers/constify-module-enums-shadow-name.h new file mode 100644 index 0000000000..38b261061b --- /dev/null +++ b/bindgen-tests/tests/headers/constify-module-enums-shadow-name.h @@ -0,0 +1,12 @@ +// bindgen-flags: --constified-enum-module foo + +enum foo { + Type, + Type_, + Type1, + Type__, +}; + +struct bar { + enum foo member; +}; diff --git a/bindgen-tests/tests/headers/constify-module-enums-simple-alias.hpp b/bindgen-tests/tests/headers/constify-module-enums-simple-alias.hpp new file mode 100644 index 0000000000..35ac4be328 --- /dev/null +++ b/bindgen-tests/tests/headers/constify-module-enums-simple-alias.hpp @@ -0,0 +1,21 @@ +// bindgen-flags: --constified-enum-module Foo + +enum class Foo { + Variant1, Variant2, Variant3, +}; + +typedef Foo Foo_alias1; +typedef Foo_alias1 Foo_alias2; +typedef Foo_alias2 Foo_alias3; + +class Bar { + Foo baz1; + Foo_alias1 baz2; + Foo_alias2 baz3; + Foo_alias3 baz4; + + Foo *baz_ptr1; + Foo_alias1 *baz_ptr2; + Foo_alias2 *baz_ptr3; + Foo_alias3 *baz_ptr4; +}; diff --git a/bindgen-tests/tests/headers/constify-module-enums-simple-nonamespace.hpp b/bindgen-tests/tests/headers/constify-module-enums-simple-nonamespace.hpp new file mode 100644 index 0000000000..5b15f5c808 --- /dev/null +++ b/bindgen-tests/tests/headers/constify-module-enums-simple-nonamespace.hpp @@ -0,0 +1,12 @@ +// bindgen-flags: --constified-enum-module one::Foo + +namespace one { + enum class Foo { + Variant1, Variant2, + }; +} + +class Bar { + one::Foo baz1; + one::Foo* baz2; +}; diff --git a/bindgen-tests/tests/headers/constify-module-enums-types.hpp b/bindgen-tests/tests/headers/constify-module-enums-types.hpp new file mode 100644 index 0000000000..96bed18f4b --- /dev/null +++ b/bindgen-tests/tests/headers/constify-module-enums-types.hpp @@ -0,0 +1,84 @@ +// bindgen-flags: --constified-enum-module ".*" + +using Uint = unsigned; +enum ExplicitTypeAlias : Uint { + SOME_CONSTANT, + SOME_OTHER_CONSTANT, +}; + +typedef enum foo { + THIS, + SHOULD_BE, + A_CONSTANT, + ALSO_THIS = 42, + AND_ALSO_THIS = 42, +} foo; + + +typedef enum { + Variant1, Variant2, Variant3, +} anon_enum; + + +namespace ns1 { + typedef enum { + THIS, + SHOULD_BE, + A_CONSTANT, + ALSO_THIS = 42, + } foo; +} + +namespace ns2 { + enum class Foo { + Variant1, + Variant2, + }; +} + +typedef foo foo_alias1; +typedef foo_alias1 foo_alias2; +typedef foo_alias2 foo_alias3; + +typedef anon_enum anon_enum_alias1; +typedef anon_enum_alias1 anon_enum_alias2; +typedef anon_enum_alias2 anon_enum_alias3; + +typedef struct bar { + foo member1; + foo_alias1 member2; + foo_alias2 member3; + foo_alias3 member4; + ns1::foo member5; + ns2::Foo *member6; + anon_enum member7; + anon_enum_alias1 member8; + anon_enum_alias2 member9; + anon_enum_alias3 member10; +} bar; + +class Baz { + ns2::Foo member1; +}; + +namespace one { + enum class Foo { + Variant1, Variant2, + }; +} + +class Bar { + one::Foo* baz; +}; + +foo *func1(foo arg1, foo *arg2, foo **arg3); +foo_alias1 *func2(foo_alias1 arg1, foo_alias1 *arg2, foo_alias1 **arg3); + +template +class Thing { + T thing; + T& get_thing(); +}; + +foo func3(Thing arg1); +foo func4(Thing< Thing > arg1); diff --git a/bindgen-tests/tests/headers/constructor-tp.hpp b/bindgen-tests/tests/headers/constructor-tp.hpp new file mode 100644 index 0000000000..3b5d54071a --- /dev/null +++ b/bindgen-tests/tests/headers/constructor-tp.hpp @@ -0,0 +1,25 @@ + +template +class Foo { +public: + Foo(); + + void doBaz(); +}; + +template +void +Foo::doBaz() { +} + +class Bar { +public: + Bar(); +}; + +template +Foo::Foo() { +} + +Bar::Bar() { +} diff --git a/bindgen-tests/tests/headers/constructors.hpp b/bindgen-tests/tests/headers/constructors.hpp new file mode 100644 index 0000000000..2f8d57b00b --- /dev/null +++ b/bindgen-tests/tests/headers/constructors.hpp @@ -0,0 +1,13 @@ + +class TestOverload { + // This one shouldn't be generated. + TestOverload(); +public: + TestOverload(int); + TestOverload(double); +}; + +class TestPublicNoArgs { +public: + TestPublicNoArgs(); +}; diff --git a/bindgen-tests/tests/headers/constructors_1_33.hpp b/bindgen-tests/tests/headers/constructors_1_33.hpp new file mode 100644 index 0000000000..b16c8c35a3 --- /dev/null +++ b/bindgen-tests/tests/headers/constructors_1_33.hpp @@ -0,0 +1,14 @@ +class TestOverload { + // This one shouldn't be generated. + TestOverload(); +public: + /// Calling this should use `mem::unintialized()` and not `MaybeUninit()` as only rust 1.36 includes that. + TestOverload(int); + /// Calling this should use `mem::unintialized()` and not `MaybeUninit()` as only rust 1.36 includes that. + TestOverload(double); +}; + +class TestPublicNoArgs { +public: + TestPublicNoArgs(); +}; diff --git a/bindgen-tests/tests/headers/contains-vs-inherits-zero-sized.hpp b/bindgen-tests/tests/headers/contains-vs-inherits-zero-sized.hpp new file mode 100644 index 0000000000..d354b0a2e5 --- /dev/null +++ b/bindgen-tests/tests/headers/contains-vs-inherits-zero-sized.hpp @@ -0,0 +1,21 @@ +/** + * This should get an `_address` byte. + */ +struct Empty {}; + +/** + * This should not get an `_address` byte, so `sizeof(Inherits)` should be + * `1`. + */ +struct Inherits : public Empty { + bool b; +}; + +/** + * This should not get an `_address` byte, but contains `Empty` which *does* get + * one, so `sizeof(Contains)` should be `1 + 1`. + */ +struct Contains { + Empty empty; + bool b; +}; diff --git a/bindgen-tests/tests/headers/convert-cpp-comment-to-rust.hpp b/bindgen-tests/tests/headers/convert-cpp-comment-to-rust.hpp new file mode 100644 index 0000000000..f5bbbf58b2 --- /dev/null +++ b/bindgen-tests/tests/headers/convert-cpp-comment-to-rust.hpp @@ -0,0 +1,14 @@ +// bindgen-flags: --no-layout-tests +typedef unsigned mbedtls_mpi_uint; + +/** + * \brief MPI structure + */ +typedef struct +{ + int s; /*!< integer sign */ + unsigned long n; /*!< total # of limbs */ + mbedtls_mpi_uint *p; /*!< pointer to limbs */ +} +mbedtls_mpi; + diff --git a/bindgen-tests/tests/headers/convert-floats.h b/bindgen-tests/tests/headers/convert-floats.h new file mode 100644 index 0000000000..08d9fe0bd2 --- /dev/null +++ b/bindgen-tests/tests/headers/convert-floats.h @@ -0,0 +1,9 @@ +// bindgen-flags: --no-convert-floats + +struct foo { + float bar, baz; + double bazz; + long double* bazzz; + float _Complex complexFloat; + double _Complex complexDouble; +}; diff --git a/bindgen-tests/tests/headers/core_ffi_c.h b/bindgen-tests/tests/headers/core_ffi_c.h new file mode 100644 index 0000000000..6df1e2f87a --- /dev/null +++ b/bindgen-tests/tests/headers/core_ffi_c.h @@ -0,0 +1,14 @@ +// bindgen-flags: --use-core --rust-target 1.64 --no-convert-floats +typedef char c_char; +typedef double c_double; +typedef float c_float; +typedef int c_int; +typedef long c_long; +typedef long long c_longlong; +typedef signed char c_schar; +typedef short c_short; +typedef unsigned char c_uchar; +typedef unsigned int c_uint; +typedef unsigned long c_ulong; +typedef unsigned long long c_ulonglong; +typedef unsigned short c_ushort; diff --git a/bindgen-tests/tests/headers/cpp-empty-layout.hpp b/bindgen-tests/tests/headers/cpp-empty-layout.hpp new file mode 100644 index 0000000000..1fe02e8978 --- /dev/null +++ b/bindgen-tests/tests/headers/cpp-empty-layout.hpp @@ -0,0 +1 @@ +struct Foo {}; diff --git a/tests/headers/crtp.hpp b/bindgen-tests/tests/headers/crtp.hpp similarity index 100% rename from tests/headers/crtp.hpp rename to bindgen-tests/tests/headers/crtp.hpp diff --git a/bindgen-tests/tests/headers/ctypes-prefix-path.h b/bindgen-tests/tests/headers/ctypes-prefix-path.h new file mode 100644 index 0000000000..10e06f893e --- /dev/null +++ b/bindgen-tests/tests/headers/ctypes-prefix-path.h @@ -0,0 +1,5 @@ +// bindgen-flags: --ctypes-prefix "libc::foo" --use-core --raw-line "#![no_std]" --raw-line "mod libc { pub mod foo { pub type c_int = i32; pub enum c_void {} } }" --rustified-enum ".*" +struct foo { + int a, b; + void* bar; +}; diff --git a/bindgen-tests/tests/headers/dash_language.h b/bindgen-tests/tests/headers/dash_language.h new file mode 100644 index 0000000000..4c8bb58dd7 --- /dev/null +++ b/bindgen-tests/tests/headers/dash_language.h @@ -0,0 +1,6 @@ +// bindgen-flags: -- -x c++ --std=c++11 + +template +struct Foo { + int bar; +}; diff --git a/tests/headers/decl_extern_int_twice.h b/bindgen-tests/tests/headers/decl_extern_int_twice.h similarity index 100% rename from tests/headers/decl_extern_int_twice.h rename to bindgen-tests/tests/headers/decl_extern_int_twice.h diff --git a/tests/headers/decl_ptr_to_array.h b/bindgen-tests/tests/headers/decl_ptr_to_array.h similarity index 100% rename from tests/headers/decl_ptr_to_array.h rename to bindgen-tests/tests/headers/decl_ptr_to_array.h diff --git a/bindgen-tests/tests/headers/default-enum-style-constified-module.h b/bindgen-tests/tests/headers/default-enum-style-constified-module.h new file mode 100644 index 0000000000..a5ba653121 --- /dev/null +++ b/bindgen-tests/tests/headers/default-enum-style-constified-module.h @@ -0,0 +1,4 @@ +// bindgen-flags: --default-enum-style moduleconsts + +typedef enum { bar, baz, blap } Foo; +void func(Foo x); diff --git a/bindgen-tests/tests/headers/default-macro-constant-type-signed.h b/bindgen-tests/tests/headers/default-macro-constant-type-signed.h new file mode 100644 index 0000000000..da3f134467 --- /dev/null +++ b/bindgen-tests/tests/headers/default-macro-constant-type-signed.h @@ -0,0 +1,3 @@ +// bindgen-flags: --default-macro-constant-type signed +// All values are i32 if they fit; otherwise i64. +#include "default-macro-constant-type.h" diff --git a/bindgen-tests/tests/headers/default-macro-constant-type-unsigned.h b/bindgen-tests/tests/headers/default-macro-constant-type-unsigned.h new file mode 100644 index 0000000000..1078e852ee --- /dev/null +++ b/bindgen-tests/tests/headers/default-macro-constant-type-unsigned.h @@ -0,0 +1,3 @@ +// bindgen-flags: --default-macro-constant-type unsigned +// Negative values are i32 or i64; others are u32 or u64. +#include "default-macro-constant-type.h" diff --git a/bindgen-tests/tests/headers/default-macro-constant-type.h b/bindgen-tests/tests/headers/default-macro-constant-type.h new file mode 100644 index 0000000000..a863362c98 --- /dev/null +++ b/bindgen-tests/tests/headers/default-macro-constant-type.h @@ -0,0 +1,52 @@ +// Test default of --default-macro-constant-type +// Negative values are i32 or i64; others are u32 or u64. + +#define N0 0 +#define N1 1ULL +#define N2 2ULL + +#define N_1 (-1LL) +#define N_2 (-2LL) + +#define MAX_U16 0xFFFFULL +#define MAX_I16 (0x8000ULL - 1) + +#define MAX_I16_Plus1 (MAX_I16 + 1) +#define MAX_U16_Plus1 (MAX_U16 + 1) + +#define MAX_I16_Minus1 (MAX_I16 - 1) +#define MAX_U16_Minus1 (MAX_U16 - 1) + +#define MIN_U16 0 +#define MIN_I16 (- (1ULL<<15)) + +#define MIN_U16_Plus1 (MIN_U16 + 1) +#define MIN_I16_Plus1 (MIN_I16 + 1) + +#define MIN_U16_Minus1 (MIN_U16 - 1) +#define MIN_I16_Minus1 (MIN_I16 - 1) + +#define MAX_U32 0xFFFFFFFFULL +#define MAX_I32 (0x80000000ULL - 1) + +#define MAX_I32_Plus1 (MAX_I32 + 1) +#define MAX_U32_Plus1 (MAX_U32 + 1) + +#define MAX_I32_Minus1 (MAX_I32 - 1) +#define MAX_U32_Minus1 (MAX_U32 - 1) + +#define MIN_U32 0 +#define MIN_I32 (- (1ULL<<31)) + +#define MIN_U32_Plus1 (MIN_U32 + 1) +#define MIN_I32_Plus1 (MIN_I32 + 1) + +#define MIN_U32_Minus1 (MIN_U32 - 1) +#define MIN_I32_Minus1 (MIN_I32 - 1) + +#define LONG12 123456789012ULL +#define LONG_12 (- 123456789012ULL) + +// Function parameter and return types are not affected. +int foo(int, signed, unsigned, char, unsigned char, signed char); +long bar(long, long long); diff --git a/bindgen-tests/tests/headers/default-template-parameter.hpp b/bindgen-tests/tests/headers/default-template-parameter.hpp new file mode 100644 index 0000000000..4deed834fa --- /dev/null +++ b/bindgen-tests/tests/headers/default-template-parameter.hpp @@ -0,0 +1,7 @@ +template +struct Foo { + T t; + U u; +}; + +static Foo bar; diff --git a/bindgen-tests/tests/headers/default_visibility_crate.h b/bindgen-tests/tests/headers/default_visibility_crate.h new file mode 100644 index 0000000000..c6f0be87c5 --- /dev/null +++ b/bindgen-tests/tests/headers/default_visibility_crate.h @@ -0,0 +1,12 @@ +// bindgen-flags: --no-layout-tests --default-visibility=crate + +struct Point { + int x; + int y; +}; + +struct Color { + char r :1; + char g :1; + char b :1; +}; diff --git a/bindgen-tests/tests/headers/default_visibility_private.h b/bindgen-tests/tests/headers/default_visibility_private.h new file mode 100644 index 0000000000..7ba75f7cb8 --- /dev/null +++ b/bindgen-tests/tests/headers/default_visibility_private.h @@ -0,0 +1,12 @@ +// bindgen-flags: --no-layout-tests --default-visibility=private + +struct Point { + int x; + int y; +}; + +struct Color { + char r :1; + char g :1; + char b :1; +}; diff --git a/bindgen-tests/tests/headers/default_visibility_private_respects_cxx_access_spec.h b/bindgen-tests/tests/headers/default_visibility_private_respects_cxx_access_spec.h new file mode 100644 index 0000000000..875484099a --- /dev/null +++ b/bindgen-tests/tests/headers/default_visibility_private_respects_cxx_access_spec.h @@ -0,0 +1,12 @@ +// bindgen-flags: --respect-cxx-access-specs --no-layout-tests --default-visibility=private + +struct Point { + int x; + int y; +}; + +struct Color { + char r :1; + char g :1; + char b :1; +}; diff --git a/bindgen-tests/tests/headers/deleted-function.hpp b/bindgen-tests/tests/headers/deleted-function.hpp new file mode 100644 index 0000000000..61848a0ae9 --- /dev/null +++ b/bindgen-tests/tests/headers/deleted-function.hpp @@ -0,0 +1,35 @@ +// bindgen-flags: --generate-inline-functions -- -std=c++11 + +class A { +public: + // Deleted function should not get a binding. + void deleted() = delete; + + // Inline functions should get bindings, whether they are defined inline + // (in the class) or out of line. + inline void inline_definition() {} + inline void out_of_line_definition(); + + // TODO: This is an edge case that we get wrong: An inline function + // without a definition in the same translation unit should still get a + // binding. We currently can't distinguish this case from a deleted member + // function because libclang doesn't provide a direct way to query for + // deleted member functions. This seems acceptable, however, as an inline + // function without a definition in the same translation unit is unlikely + // to be useful in practice. + inline void inline_without_definition(); +}; + +void A::out_of_line_definition() {} + +class B { +public: + // Deleted copy constructor should not get a binding. + B(B&) = delete; +}; + +class C { +public: + // Defaulted copy constructor should get a binding. + C(C&) = default; +}; \ No newline at end of file diff --git a/bindgen-tests/tests/headers/derive-bitfield-method-same-name.hpp b/bindgen-tests/tests/headers/derive-bitfield-method-same-name.hpp new file mode 100644 index 0000000000..4b7b21e93a --- /dev/null +++ b/bindgen-tests/tests/headers/derive-bitfield-method-same-name.hpp @@ -0,0 +1,13 @@ +// bindgen-flags: --with-derive-partialeq --impl-partialeq --impl-debug + +/// Because this struct have array larger than 32 items +/// and --with-derive-partialeq --impl-partialeq --impl-debug is provided, +/// this struct should manually implement `Debug` and `PartialEq`. +struct Foo { + int large[33]; + char type_ : 3; + unsigned : 8; + char type(); + void set_type_(char c); + void set_type(char c); +}; diff --git a/bindgen-tests/tests/headers/derive-clone.h b/bindgen-tests/tests/headers/derive-clone.h new file mode 100644 index 0000000000..8dc30eacfc --- /dev/null +++ b/bindgen-tests/tests/headers/derive-clone.h @@ -0,0 +1,4 @@ +/// This struct should derive `Clone`. +struct ShouldDeriveClone { + int large[33]; +}; diff --git a/bindgen-tests/tests/headers/derive-custom-cli.h b/bindgen-tests/tests/headers/derive-custom-cli.h new file mode 100644 index 0000000000..9b65536f94 --- /dev/null +++ b/bindgen-tests/tests/headers/derive-custom-cli.h @@ -0,0 +1,14 @@ +// bindgen-flags: --default-enum-style rust --default-non-copy-union-style manually_drop --no-default=".*" --no-hash=".*" --no-partialeq=".*" --no-debug=".*" --no-copy=".*" --with-derive-custom="foo_[^e].*=Clone" --with-derive-custom-struct="foo.*=Default" --with-derive-custom-enum="foo.*=Copy" --with-derive-custom-union="foo.*=Copy" +struct foo_struct { + int inner; +}; +enum foo_enum { + inner = 0 +}; +union foo_union { + int fst; + float snd; +}; +struct non_matching { + int inner; +}; diff --git a/bindgen-tests/tests/headers/derive-custom.h b/bindgen-tests/tests/headers/derive-custom.h new file mode 100644 index 0000000000..8c57278cb3 --- /dev/null +++ b/bindgen-tests/tests/headers/derive-custom.h @@ -0,0 +1,28 @@ +// bindgen-flags: --no-derive-debug --no-derive-copy --default-enum-style rust --no-layout-tests + +/**
*/ +struct my_type; + +/**
*/ +struct my_type; + +struct my_type { + int a; +}; + +/** + *
+ *
+ */ +struct my_type2; + +struct my_type2 { + unsigned a; +}; + +/** + *
+ */ +struct my_type3 { + unsigned long a; +}; diff --git a/bindgen-tests/tests/headers/derive-debug-bitfield-1-51.hpp b/bindgen-tests/tests/headers/derive-debug-bitfield-1-51.hpp new file mode 100644 index 0000000000..df43e6a7c2 --- /dev/null +++ b/bindgen-tests/tests/headers/derive-debug-bitfield-1-51.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --impl-debug + +class C { + bool a: 1; + bool b: 7; + int large_array[50]; +}; diff --git a/bindgen-tests/tests/headers/derive-debug-bitfield-core.hpp b/bindgen-tests/tests/headers/derive-debug-bitfield-core.hpp new file mode 100644 index 0000000000..5d78e74359 --- /dev/null +++ b/bindgen-tests/tests/headers/derive-debug-bitfield-core.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --impl-debug --use-core --raw-line "extern crate core;" + +class C { + bool a: 1; + bool b: 7; + int large_array[50]; +}; diff --git a/bindgen-tests/tests/headers/derive-debug-bitfield.hpp b/bindgen-tests/tests/headers/derive-debug-bitfield.hpp new file mode 100644 index 0000000000..df43e6a7c2 --- /dev/null +++ b/bindgen-tests/tests/headers/derive-debug-bitfield.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --impl-debug + +class C { + bool a: 1; + bool b: 7; + int large_array[50]; +}; diff --git a/bindgen-tests/tests/headers/derive-debug-function-pointer.hpp b/bindgen-tests/tests/headers/derive-debug-function-pointer.hpp new file mode 100644 index 0000000000..a370dee813 --- /dev/null +++ b/bindgen-tests/tests/headers/derive-debug-function-pointer.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --impl-debug + +class Nice { + typedef void (*Function) (int data); + Function pointer; + int large_array[34]; +}; diff --git a/bindgen-tests/tests/headers/derive-debug-generic.hpp b/bindgen-tests/tests/headers/derive-debug-generic.hpp new file mode 100644 index 0000000000..d5158510ea --- /dev/null +++ b/bindgen-tests/tests/headers/derive-debug-generic.hpp @@ -0,0 +1,6 @@ +// bindgen-flags: --impl-debug + +template +class Generic { + T t[40]; +}; diff --git a/bindgen-tests/tests/headers/derive-debug-mangle-name.h b/bindgen-tests/tests/headers/derive-debug-mangle-name.h new file mode 100644 index 0000000000..1cd7db633b --- /dev/null +++ b/bindgen-tests/tests/headers/derive-debug-mangle-name.h @@ -0,0 +1,14 @@ +// bindgen-flags: --impl-debug +struct perf_event_attr { + + /* + * Major type: hardware/software/tracepoint/etc. + */ + unsigned int type; + + float a; + union { + int b; + int c; + }; +}; diff --git a/bindgen-tests/tests/headers/derive-debug-opaque-template-instantiation.hpp b/bindgen-tests/tests/headers/derive-debug-opaque-template-instantiation.hpp new file mode 100644 index 0000000000..0dead782ff --- /dev/null +++ b/bindgen-tests/tests/headers/derive-debug-opaque-template-instantiation.hpp @@ -0,0 +1,12 @@ +// bindgen-flags: --impl-debug + +// This type is opaque because the second template parameter +// is a non-type template parameter +template +class Opaque { + T array[N]; +}; + +class Instance { + Opaque val; +}; diff --git a/bindgen-tests/tests/headers/derive-debug-opaque.hpp b/bindgen-tests/tests/headers/derive-debug-opaque.hpp new file mode 100644 index 0000000000..0ce1d63ab8 --- /dev/null +++ b/bindgen-tests/tests/headers/derive-debug-opaque.hpp @@ -0,0 +1,10 @@ +// bindgen-flags: --opaque-type "Opaque" --impl-debug + +class Opaque { + int i; + int not_debug[40]; +}; + +class OpaqueUser { + Opaque opaque; +}; diff --git a/bindgen-tests/tests/headers/derive-default-and-blocklist.hpp b/bindgen-tests/tests/headers/derive-default-and-blocklist.hpp new file mode 100644 index 0000000000..20d938ccf2 --- /dev/null +++ b/bindgen-tests/tests/headers/derive-default-and-blocklist.hpp @@ -0,0 +1,14 @@ +// bindgen-flags: --blocklist-type BlocklistMe --raw-line 'pub struct BlocklistMe(u8);' + +// Note that we do not explicitly provide the `--with-derive-default` flag +// above, since it is added by the test runner implicitly. + +struct BlocklistMe {}; + +/** + * Because this type contains a blocklisted type, it should not derive + * Default. Instead, we should emit a `mem::zeroed` implementation. + */ +struct ShouldNotDeriveDefault { + BlocklistMe a; +}; diff --git a/bindgen-tests/tests/headers/derive-fn-ptr.h b/bindgen-tests/tests/headers/derive-fn-ptr.h new file mode 100644 index 0000000000..93b980e6f4 --- /dev/null +++ b/bindgen-tests/tests/headers/derive-fn-ptr.h @@ -0,0 +1,18 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +typedef void (*my_fun_t)(int, int, int, int, + int, int, int, int, + int, int, int, int, + int, int, int, int); + +struct Foo { + my_fun_t callback; +}; + +typedef void (*my_fun2_t)(int, int, int, int, + int, int, int, int, + int, int, int, int); + +struct Bar { + my_fun2_t callback; +}; diff --git a/bindgen-tests/tests/headers/derive-hash-and-blocklist.hpp b/bindgen-tests/tests/headers/derive-hash-and-blocklist.hpp new file mode 100644 index 0000000000..51a3372fcf --- /dev/null +++ b/bindgen-tests/tests/headers/derive-hash-and-blocklist.hpp @@ -0,0 +1,10 @@ +// bindgen-flags: --with-derive-hash --blocklist-type BlocklistMe --raw-line 'pub struct BlocklistMe(u8);' + +struct BlocklistMe {}; + +/** + * Because this type contains a blocklisted type, it should not derive Hash. + */ +struct ShouldNotDeriveHash { + BlocklistMe a; +}; diff --git a/bindgen-tests/tests/headers/derive-hash-blocklisting.hpp b/bindgen-tests/tests/headers/derive-hash-blocklisting.hpp new file mode 100644 index 0000000000..4e20e3925a --- /dev/null +++ b/bindgen-tests/tests/headers/derive-hash-blocklisting.hpp @@ -0,0 +1,17 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialord --with-derive-ord --with-derive-partialeq --with-derive-eq --allowlist-type 'Allowlisted.*' --blocklist-type Blocklisted --raw-line "#[repr(C)] #[derive(Debug, Hash, Copy, Clone, PartialEq, Eq)] pub struct Blocklisted {t: T, pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell> }" +// +template +struct Blocklisted { + T t; +}; + +/// This would derive(Hash, Eq, PartialEq) if it didn't contain a blocklisted type, +/// causing us to conservatively avoid deriving hash/Eq/PartialEq for it. +struct AllowlistedOne { + Blocklisted a; +}; + +/// This can't derive(Hash/Eq) even if it didn't contain a blocklisted type. +struct AllowlistedTwo { + Blocklisted b; +}; diff --git a/bindgen-tests/tests/headers/derive-hash-struct-with-anon-struct-float.h b/bindgen-tests/tests/headers/derive-hash-struct-with-anon-struct-float.h new file mode 100644 index 0000000000..dc6e73292d --- /dev/null +++ b/bindgen-tests/tests/headers/derive-hash-struct-with-anon-struct-float.h @@ -0,0 +1,9 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialord --with-derive-ord --with-derive-partialeq --with-derive-eq +// +/// A struct containing a struct containing a float that cannot derive Hash/Eq/Ord but can derive PartialEq/PartialOrd +struct foo { + struct { + float a; + float b; + } bar; +}; diff --git a/bindgen-tests/tests/headers/derive-hash-struct-with-float-array.h b/bindgen-tests/tests/headers/derive-hash-struct-with-float-array.h new file mode 100644 index 0000000000..2294b1decf --- /dev/null +++ b/bindgen-tests/tests/headers/derive-hash-struct-with-float-array.h @@ -0,0 +1,6 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialord --with-derive-ord --with-derive-partialeq --with-derive-eq +// +/// A struct containing an array of floats that cannot derive Hash/Eq/Ord but can derive PartialEq/PartialOrd +struct foo { + float bar[3]; +}; diff --git a/bindgen-tests/tests/headers/derive-hash-struct-with-incomplete-array.h b/bindgen-tests/tests/headers/derive-hash-struct-with-incomplete-array.h new file mode 100644 index 0000000000..65c009db0c --- /dev/null +++ b/bindgen-tests/tests/headers/derive-hash-struct-with-incomplete-array.h @@ -0,0 +1,17 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --with-derive-partialord --with-derive-ord +// +struct test { + int a; + char zero_length_array[0]; +}; + +struct test2 { + int a; + char incomplete_array[]; +}; + +struct test3 { + int a; + char zero_length_array[0]; + char incomplete_array[]; +}; diff --git a/bindgen-tests/tests/headers/derive-hash-struct-with-pointer.h b/bindgen-tests/tests/headers/derive-hash-struct-with-pointer.h new file mode 100644 index 0000000000..a3ce9cc5d0 --- /dev/null +++ b/bindgen-tests/tests/headers/derive-hash-struct-with-pointer.h @@ -0,0 +1,18 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialord --with-derive-ord --with-derive-partialeq --with-derive-eq +// +/// Pointers can derive Hash/PartialOrd/Ord/PartialEq/Eq +struct ConstPtrMutObj { + int* const bar; +}; + +struct MutPtrMutObj { + int* bar; +}; + +struct MutPtrConstObj { + const int* bar; +}; + +struct ConstPtrConstObj { + const int* const bar; +}; diff --git a/bindgen-tests/tests/headers/derive-hash-template-def-float.hpp b/bindgen-tests/tests/headers/derive-hash-template-def-float.hpp new file mode 100644 index 0000000000..253fb9cea2 --- /dev/null +++ b/bindgen-tests/tests/headers/derive-hash-template-def-float.hpp @@ -0,0 +1,8 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialord --with-derive-ord --with-derive-partialeq --with-derive-eq +// +/// Template definition containing a float, which cannot derive Hash/Eq/Ord but can derive PartialEq/PartialOrd. +template +struct foo { + T data; + float b; +}; diff --git a/bindgen-tests/tests/headers/derive-hash-template-inst-float.hpp b/bindgen-tests/tests/headers/derive-hash-template-inst-float.hpp new file mode 100644 index 0000000000..0a4fc0c1f4 --- /dev/null +++ b/bindgen-tests/tests/headers/derive-hash-template-inst-float.hpp @@ -0,0 +1,17 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialord --with-derive-ord --with-derive-partialeq --with-derive-eq +// +/// Template definition that doesn't contain float can derive Hash/PartialOrd/Ord/PartialEq/Eq +template +struct foo { + T data; +}; + +/// Can derive Hash/PartialOrd/Ord/PartialEq/Eq when instantiated with int +struct IntStr { + foo a; +}; + +/// Cannot derive Hash/Eq/Ord when instantiated with float but can derive PartialEq/PartialOrd +struct FloatStr { + foo a; +}; diff --git a/bindgen-tests/tests/headers/derive-partialeq-and-blocklist.hpp b/bindgen-tests/tests/headers/derive-partialeq-and-blocklist.hpp new file mode 100644 index 0000000000..953d067714 --- /dev/null +++ b/bindgen-tests/tests/headers/derive-partialeq-and-blocklist.hpp @@ -0,0 +1,11 @@ +// bindgen-flags: --with-derive-partialeq --blocklist-type BlocklistMe --raw-line 'pub struct BlocklistMe(u8);' + +struct BlocklistMe {}; + +/** + * Because this type contains a blocklisted type, it should not derive + * PartialEq. + */ +struct ShouldNotDerivePartialEq { + BlocklistMe a; +}; diff --git a/bindgen-tests/tests/headers/derive-partialeq-anonfield.h b/bindgen-tests/tests/headers/derive-partialeq-anonfield.h new file mode 100644 index 0000000000..3bbe2bc331 --- /dev/null +++ b/bindgen-tests/tests/headers/derive-partialeq-anonfield.h @@ -0,0 +1,5 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --impl-partialeq + +struct rte_mbuf { + union {}; +} __attribute__((__aligned__(64))); diff --git a/bindgen-tests/tests/headers/derive-partialeq-base.hpp b/bindgen-tests/tests/headers/derive-partialeq-base.hpp new file mode 100644 index 0000000000..989cbe693a --- /dev/null +++ b/bindgen-tests/tests/headers/derive-partialeq-base.hpp @@ -0,0 +1,8 @@ +// bindgen-flags: --with-derive-partialeq --impl-partialeq + +class Base { + int large[33]; +}; + +class ShouldDerivePartialEq: Base { +}; diff --git a/bindgen-tests/tests/headers/derive-partialeq-bitfield.hpp b/bindgen-tests/tests/headers/derive-partialeq-bitfield.hpp new file mode 100644 index 0000000000..ac2cac632a --- /dev/null +++ b/bindgen-tests/tests/headers/derive-partialeq-bitfield.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --with-derive-partialeq --impl-partialeq + +class C { + bool a: 1; + bool b: 7; + int large_array[50]; +}; diff --git a/bindgen-tests/tests/headers/derive-partialeq-core.h b/bindgen-tests/tests/headers/derive-partialeq-core.h new file mode 100644 index 0000000000..6da5b786bc --- /dev/null +++ b/bindgen-tests/tests/headers/derive-partialeq-core.h @@ -0,0 +1,5 @@ +// bindgen-flags: --with-derive-partialeq --impl-partialeq --use-core --raw-line "extern crate core;" + +struct C { + int large_array[420]; +}; diff --git a/bindgen-tests/tests/headers/derive-partialeq-pointer.hpp b/bindgen-tests/tests/headers/derive-partialeq-pointer.hpp new file mode 100644 index 0000000000..ce971e075b --- /dev/null +++ b/bindgen-tests/tests/headers/derive-partialeq-pointer.hpp @@ -0,0 +1,12 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq + +struct a; +class Bar { + a *b; +}; +struct c { + union {}; +}; +struct a { + c d; +}; diff --git a/bindgen-tests/tests/headers/derive-partialeq-union.hpp b/bindgen-tests/tests/headers/derive-partialeq-union.hpp new file mode 100644 index 0000000000..e2081a013a --- /dev/null +++ b/bindgen-tests/tests/headers/derive-partialeq-union.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --with-derive-partialeq --impl-partialeq + +/// Deriving PartialEq for rust unions is not supported. +union ShouldNotDerivePartialEq { + char a; + int b; +}; diff --git a/bindgen-tests/tests/headers/disable-namespacing.hpp b/bindgen-tests/tests/headers/disable-namespacing.hpp new file mode 100644 index 0000000000..11191361c0 --- /dev/null +++ b/bindgen-tests/tests/headers/disable-namespacing.hpp @@ -0,0 +1,9 @@ +// bindgen-flags: --disable-name-namespacing + +namespace foo { +namespace bar { + +typedef int Baz; + +} +} diff --git a/bindgen-tests/tests/headers/disable-nested-struct-naming.h b/bindgen-tests/tests/headers/disable-nested-struct-naming.h new file mode 100644 index 0000000000..0e4fccb6e2 --- /dev/null +++ b/bindgen-tests/tests/headers/disable-nested-struct-naming.h @@ -0,0 +1,24 @@ +// bindgen-flags: --disable-nested-struct-naming + +struct foo { + struct bar1 { + int x1; + struct { + int x2; + struct { + int x3; + struct bar4 { + int x4; + } b4; + } b3; + } b2; + } b1; +}; + +struct { + struct { + struct baz { + int x; + } b; + } anon2; +} anon1; diff --git a/bindgen-tests/tests/headers/disable-untagged-union.hpp b/bindgen-tests/tests/headers/disable-untagged-union.hpp new file mode 100644 index 0000000000..4462318171 --- /dev/null +++ b/bindgen-tests/tests/headers/disable-untagged-union.hpp @@ -0,0 +1,6 @@ +// bindgen-flags: --disable-untagged-union + +union Foo { + int bar; + unsigned int baz; +}; diff --git a/bindgen-tests/tests/headers/divide-by-zero-in-struct-layout.h b/bindgen-tests/tests/headers/divide-by-zero-in-struct-layout.h new file mode 100644 index 0000000000..7c500cb06d --- /dev/null +++ b/bindgen-tests/tests/headers/divide-by-zero-in-struct-layout.h @@ -0,0 +1,22 @@ +// bindgen-flags: --no-layout-tests +// +// Unfortunately, we aren't translating the third struct correctly yet. But we +// definitely shouldn't divide-by-zero when we see it... +// +// Once we fix #981 we should remove the `--no-layout-tests`. + +struct WithBitfield { + unsigned : 7; + unsigned a; +}; + +struct WithBitfieldAndAttrPacked { + unsigned : 7; + unsigned a; +} __attribute__((packed)); + +#pragma pack(1) +struct WithBitfieldAndPacked { + unsigned : 7; + unsigned a; +}; diff --git a/bindgen-tests/tests/headers/do-not-derive-copy.hpp b/bindgen-tests/tests/headers/do-not-derive-copy.hpp new file mode 100644 index 0000000000..18c2613540 --- /dev/null +++ b/bindgen-tests/tests/headers/do-not-derive-copy.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: --no-derive-copy + +class WouldBeCopyButWeAreNotDerivingCopy { + int x; +}; diff --git a/bindgen-tests/tests/headers/doggo-or-null.hpp b/bindgen-tests/tests/headers/doggo-or-null.hpp new file mode 100644 index 0000000000..9146e18996 --- /dev/null +++ b/bindgen-tests/tests/headers/doggo-or-null.hpp @@ -0,0 +1,20 @@ +// bindgen-flags: --opaque-type DoggoOrNull --with-derive-partialeq --with-derive-hash -- -std=c++14 + +class Doggo { + int x; +}; + +class Null {}; + +/** + * This type is an opaque union. Unions can't derive anything interesting like + * Debug or Default, even if their layout can, because it would require knowing + * which variant is in use. Opaque unions still end up as a `union` in the Rust + * bindings, but they just have one variant. Even so, can't derive. We should + * probably emit an opaque struct for opaque unions... but until then, we have + * this test to make sure that opaque unions don't derive and still compile. + */ +union DoggoOrNull { + Doggo doggo; + Null none; +}; diff --git a/bindgen-tests/tests/headers/dupe-enum-variant-in-namespace.h b/bindgen-tests/tests/headers/dupe-enum-variant-in-namespace.h new file mode 100644 index 0000000000..2b6fb93a8e --- /dev/null +++ b/bindgen-tests/tests/headers/dupe-enum-variant-in-namespace.h @@ -0,0 +1,10 @@ +// bindgen-flags: --rustified-enum ".*" --enable-cxx-namespaces -- -x c++ -std=c++11 + +namespace foo { + enum class Bar : unsigned { + Foo = 0, + Foo1 = 0, + Foo2, + Foo3 = Foo2, + }; +} diff --git a/bindgen-tests/tests/headers/duplicated-definition-count.hpp b/bindgen-tests/tests/headers/duplicated-definition-count.hpp new file mode 100644 index 0000000000..2916762617 --- /dev/null +++ b/bindgen-tests/tests/headers/duplicated-definition-count.hpp @@ -0,0 +1,6 @@ +class BitStream { + public: + void Write(const char *inputByteArray, unsigned int numberOfBytes); + void Write(BitStream *bitStream, unsigned numberOfBits); + void Write1(); +}; diff --git a/bindgen-tests/tests/headers/duplicated-namespaces-definitions.hpp b/bindgen-tests/tests/headers/duplicated-namespaces-definitions.hpp new file mode 100644 index 0000000000..7c8888def2 --- /dev/null +++ b/bindgen-tests/tests/headers/duplicated-namespaces-definitions.hpp @@ -0,0 +1,18 @@ +// bindgen-flags: --enable-cxx-namespaces + +namespace foo { + class Bar; +} + +namespace bar { + struct Foo { + foo::Bar* ptr; + }; +}; + +namespace foo { + class Bar { + int foo; + bool baz; + }; +} diff --git a/bindgen-tests/tests/headers/duplicated-namespaces.hpp b/bindgen-tests/tests/headers/duplicated-namespaces.hpp new file mode 100644 index 0000000000..10e1933f43 --- /dev/null +++ b/bindgen-tests/tests/headers/duplicated-namespaces.hpp @@ -0,0 +1,4 @@ +// bindgen-flags: --enable-cxx-namespaces + +namespace std {} +namespace std {} diff --git a/tests/headers/duplicated_constants_in_ns.hpp b/bindgen-tests/tests/headers/duplicated_constants_in_ns.hpp similarity index 100% rename from tests/headers/duplicated_constants_in_ns.hpp rename to bindgen-tests/tests/headers/duplicated_constants_in_ns.hpp diff --git a/bindgen-tests/tests/headers/dynamic_loading_attributes.h b/bindgen-tests/tests/headers/dynamic_loading_attributes.h new file mode 100644 index 0000000000..e2ca62b159 --- /dev/null +++ b/bindgen-tests/tests/headers/dynamic_loading_attributes.h @@ -0,0 +1,11 @@ +// bindgen-flags: --dynamic-loading TestLib --dynamic-link-require-all --enable-function-attribute-detection +/** + * @brief A function + * + * @param x + * @param y + * @return int + */ +__attribute__((warn_unused_result)) +int foo(int x, int y); +int baz() ; diff --git a/bindgen-tests/tests/headers/dynamic_loading_required.h b/bindgen-tests/tests/headers/dynamic_loading_required.h new file mode 100644 index 0000000000..f9861e84eb --- /dev/null +++ b/bindgen-tests/tests/headers/dynamic_loading_required.h @@ -0,0 +1,5 @@ +// bindgen-flags: --dynamic-loading TestLib --dynamic-link-require-all + +int foo(int x, int y); +int bar(void *x); +int baz(); diff --git a/bindgen-tests/tests/headers/dynamic_loading_simple.h b/bindgen-tests/tests/headers/dynamic_loading_simple.h new file mode 100644 index 0000000000..f418851beb --- /dev/null +++ b/bindgen-tests/tests/headers/dynamic_loading_simple.h @@ -0,0 +1,5 @@ +// bindgen-flags: --dynamic-loading TestLib + +int foo(int x, int y); +int bar(void *x); +int baz(); diff --git a/bindgen-tests/tests/headers/dynamic_loading_template.hpp b/bindgen-tests/tests/headers/dynamic_loading_template.hpp new file mode 100644 index 0000000000..27f04c8e29 --- /dev/null +++ b/bindgen-tests/tests/headers/dynamic_loading_template.hpp @@ -0,0 +1,10 @@ +// bindgen-flags: --dynamic-loading TestLib + +template +T foo(T x); + +template<> +int foo(int x); + +template<> +float foo(float x); diff --git a/bindgen-tests/tests/headers/dynamic_loading_variable_required.h b/bindgen-tests/tests/headers/dynamic_loading_variable_required.h new file mode 100644 index 0000000000..8e811bb320 --- /dev/null +++ b/bindgen-tests/tests/headers/dynamic_loading_variable_required.h @@ -0,0 +1,4 @@ +// bindgen-flags: --dynamic-loading TestLib --dynamic-link-require-all + +int foo; +int *baz; \ No newline at end of file diff --git a/bindgen-tests/tests/headers/dynamic_loading_variable_simple.h b/bindgen-tests/tests/headers/dynamic_loading_variable_simple.h new file mode 100644 index 0000000000..5ecad752ed --- /dev/null +++ b/bindgen-tests/tests/headers/dynamic_loading_variable_simple.h @@ -0,0 +1,4 @@ +// bindgen-flags: --dynamic-loading TestLib + +int foo; +int *baz; \ No newline at end of file diff --git a/bindgen-tests/tests/headers/dynamic_loading_variable_with_allowlist.hpp b/bindgen-tests/tests/headers/dynamic_loading_variable_with_allowlist.hpp new file mode 100644 index 0000000000..5e27303063 --- /dev/null +++ b/bindgen-tests/tests/headers/dynamic_loading_variable_with_allowlist.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: --dynamic-loading TestLib --allowlist-var foo --allowlist-var bar + +int foo; +int bar; +int baz; // should not be allowed \ No newline at end of file diff --git a/bindgen-tests/tests/headers/dynamic_loading_with_allowlist.hpp b/bindgen-tests/tests/headers/dynamic_loading_with_allowlist.hpp new file mode 100644 index 0000000000..995fbdd531 --- /dev/null +++ b/bindgen-tests/tests/headers/dynamic_loading_with_allowlist.hpp @@ -0,0 +1,16 @@ +// bindgen-flags: --dynamic-loading TestLib --allowlist-function baz --allowlist-function foo --allowlist-function bazz + +class X { + int _x; + + public: + X(int x); + + void some_function(); + void some_other_function(); +}; + +int foo(void *x); +int bar(void *x); +int baz(void *x); +int bazz(int, ...); diff --git a/bindgen-tests/tests/headers/dynamic_loading_with_blocklist.hpp b/bindgen-tests/tests/headers/dynamic_loading_with_blocklist.hpp new file mode 100644 index 0000000000..81266d1f40 --- /dev/null +++ b/bindgen-tests/tests/headers/dynamic_loading_with_blocklist.hpp @@ -0,0 +1,15 @@ +// bindgen-flags: --dynamic-loading TestLib --blocklist-function baz + +class X { + int _x; + + public: + X(int x); + + void some_function(); + void some_other_function(); +}; + +int foo(void *x); +int bar(void *x); +int baz(void *x); diff --git a/bindgen-tests/tests/headers/dynamic_loading_with_class.hpp b/bindgen-tests/tests/headers/dynamic_loading_with_class.hpp new file mode 100644 index 0000000000..632db4d065 --- /dev/null +++ b/bindgen-tests/tests/headers/dynamic_loading_with_class.hpp @@ -0,0 +1,15 @@ +// bindgen-flags: --dynamic-loading TestLib + +int foo(void *x); + +class A { + int _x; + + public: + A(int x); + + void some_function(); + void some_other_function(); +}; + +void bar(); diff --git a/tests/headers/elaborated.hpp b/bindgen-tests/tests/headers/elaborated.hpp similarity index 100% rename from tests/headers/elaborated.hpp rename to bindgen-tests/tests/headers/elaborated.hpp diff --git a/bindgen-tests/tests/headers/empty-enum.h b/bindgen-tests/tests/headers/empty-enum.h new file mode 100644 index 0000000000..8b7502e671 --- /dev/null +++ b/bindgen-tests/tests/headers/empty-enum.h @@ -0,0 +1,15 @@ +// bindgen-flags: --rustified-enum '.*Rustified.*' --constified-enum-module '.*Module.*' -- -x c++ --std=c++14 + +// Constified is default, so no flag for that. + +enum EmptyConstified {}; +enum EmptyRustified {}; +enum EmptyModule {}; + +enum class EmptyClassRustified : char {}; +enum class EmptyClassConstified : char {}; +enum class EmptyClassModule : char {}; + +enum class ForwardClassRustified : char; +enum class ForwardClassConstified : char; +enum class ForwardClassModule : char; diff --git a/bindgen-tests/tests/headers/empty-union.hpp b/bindgen-tests/tests/headers/empty-union.hpp new file mode 100644 index 0000000000..113a95ee30 --- /dev/null +++ b/bindgen-tests/tests/headers/empty-union.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: --opaque-type ".*" + +template class a { + union {}; +}; diff --git a/bindgen-tests/tests/headers/empty_template_param_name.hpp b/bindgen-tests/tests/headers/empty_template_param_name.hpp new file mode 100644 index 0000000000..ab2aab9241 --- /dev/null +++ b/bindgen-tests/tests/headers/empty_template_param_name.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// bindgen-flags: -- -std=c++11 + +template using __void_t = void; + +template> + struct __iterator_traits { }; diff --git a/bindgen-tests/tests/headers/enum-default-bitfield.h b/bindgen-tests/tests/headers/enum-default-bitfield.h new file mode 100644 index 0000000000..5f3cb95468 --- /dev/null +++ b/bindgen-tests/tests/headers/enum-default-bitfield.h @@ -0,0 +1,3 @@ +// bindgen-flags: --default-enum-style=bitfield --constified-enum-module=Neg + +#include "enum.h" diff --git a/bindgen-tests/tests/headers/enum-default-consts.h b/bindgen-tests/tests/headers/enum-default-consts.h new file mode 100644 index 0000000000..233d2718a4 --- /dev/null +++ b/bindgen-tests/tests/headers/enum-default-consts.h @@ -0,0 +1,3 @@ +// bindgen-flags: --default-enum-style=consts --constified-enum-module=Neg + +#include "enum.h" diff --git a/bindgen-tests/tests/headers/enum-default-module.h b/bindgen-tests/tests/headers/enum-default-module.h new file mode 100644 index 0000000000..8c2ec1bca4 --- /dev/null +++ b/bindgen-tests/tests/headers/enum-default-module.h @@ -0,0 +1,3 @@ +// bindgen-flags: --default-enum-style=moduleconsts --constified-enum-module=Neg + +#include "enum.h" diff --git a/bindgen-tests/tests/headers/enum-default-rust.h b/bindgen-tests/tests/headers/enum-default-rust.h new file mode 100644 index 0000000000..7fd2999fe0 --- /dev/null +++ b/bindgen-tests/tests/headers/enum-default-rust.h @@ -0,0 +1,3 @@ +// bindgen-flags: --default-enum-style=rust --constified-enum-module=Neg + +#include "enum.h" diff --git a/bindgen-tests/tests/headers/enum-doc-bitfield.h b/bindgen-tests/tests/headers/enum-doc-bitfield.h new file mode 100644 index 0000000000..5bbd728744 --- /dev/null +++ b/bindgen-tests/tests/headers/enum-doc-bitfield.h @@ -0,0 +1,3 @@ +// bindgen-flags: --bitfield-enum B + +#include "enum-doc.h" diff --git a/bindgen-tests/tests/headers/enum-doc-mod.h b/bindgen-tests/tests/headers/enum-doc-mod.h new file mode 100644 index 0000000000..e5217451ba --- /dev/null +++ b/bindgen-tests/tests/headers/enum-doc-mod.h @@ -0,0 +1,3 @@ +// bindgen-flags: --constified-enum-module B + +#include "enum-doc.h" diff --git a/bindgen-tests/tests/headers/enum-doc-rusty-non-exhaustive.h b/bindgen-tests/tests/headers/enum-doc-rusty-non-exhaustive.h new file mode 100644 index 0000000000..b544a0c4fc --- /dev/null +++ b/bindgen-tests/tests/headers/enum-doc-rusty-non-exhaustive.h @@ -0,0 +1,3 @@ +// bindgen-flags: --rustified-non-exhaustive-enum B + +#include "enum-doc.h" diff --git a/bindgen-tests/tests/headers/enum-doc-rusty.h b/bindgen-tests/tests/headers/enum-doc-rusty.h new file mode 100644 index 0000000000..35622d2b06 --- /dev/null +++ b/bindgen-tests/tests/headers/enum-doc-rusty.h @@ -0,0 +1,3 @@ +// bindgen-flags: --rustified-enum B + +#include "enum-doc.h" diff --git a/bindgen-tests/tests/headers/enum-doc.h b/bindgen-tests/tests/headers/enum-doc.h new file mode 100644 index 0000000000..7a2f425cda --- /dev/null +++ b/bindgen-tests/tests/headers/enum-doc.h @@ -0,0 +1,18 @@ +/** Document enum */ +enum B { + /// Document field with three slashes + VAR_A = 0, + /** Document field with preceding star */ + VAR_B = 1, + /*! Document field with preceding exclamation */ + VAR_C = 2, + VAR_D = 3, /**< Document field with following star */ + VAR_E = 4, /*!< Document field with following exclamation */ + /** + * Document field with preceding star, with a loong long multiline + * comment. + * + * Very interesting documentation, definitely. + */ + VAR_F, +}; diff --git a/bindgen-tests/tests/headers/enum-no-debug-rust.h b/bindgen-tests/tests/headers/enum-no-debug-rust.h new file mode 100644 index 0000000000..7cb7398029 --- /dev/null +++ b/bindgen-tests/tests/headers/enum-no-debug-rust.h @@ -0,0 +1,3 @@ +// bindgen-flags: --no-derive-debug --default-enum-style=rust --constified-enum-module=Neg + +#include "enum.h" diff --git a/bindgen-tests/tests/headers/enum-translate-type.hpp b/bindgen-tests/tests/headers/enum-translate-type.hpp new file mode 100644 index 0000000000..8d85626105 --- /dev/null +++ b/bindgen-tests/tests/headers/enum-translate-type.hpp @@ -0,0 +1,14 @@ +// bindgen-flags: --translate-enum-integer-types -- -std=c++11 -Wno-narrowing + +enum my_enum1 { + A = 0, +}; +enum my_enum2 { + B = -1, +}; +enum my_enum3: short { + C = 0, +}; +enum my_enum4: unsigned char { + D = -1, +}; diff --git a/bindgen-tests/tests/headers/enum-typedef.h b/bindgen-tests/tests/headers/enum-typedef.h new file mode 100644 index 0000000000..f345f4de27 --- /dev/null +++ b/bindgen-tests/tests/headers/enum-typedef.h @@ -0,0 +1,18 @@ +typedef short int16_t; + +// `cbindgen` emits this C idiom as the translation of: +// +// #[repr(i16)] +// pub enum Enum { +// Variant, +// } +enum Enum { + Variant, +}; +typedef int16_t Enum; + +// C is also fine with the typedef coming before the enum. +typedef int16_t TypedefFirst; +enum TypedefFirst { + Variant2, +}; diff --git a/bindgen-tests/tests/headers/enum-undefault.h b/bindgen-tests/tests/headers/enum-undefault.h new file mode 100644 index 0000000000..7150be0dd9 --- /dev/null +++ b/bindgen-tests/tests/headers/enum-undefault.h @@ -0,0 +1,11 @@ +// bindgen-flags: --default-enum-style=rust --constified-enum=Neg + +enum Foo { + Bar = 0, + Qux +}; + +enum Neg { + MinusOne = -1, + One = 1, +}; diff --git a/bindgen-tests/tests/headers/enum-variant-replaces.h b/bindgen-tests/tests/headers/enum-variant-replaces.h new file mode 100644 index 0000000000..45eb4d7a54 --- /dev/null +++ b/bindgen-tests/tests/headers/enum-variant-replaces.h @@ -0,0 +1,34 @@ + +/** Type for a OGR error */ +typedef enum +{ + OGRERR_NONE, /**< Success */ + OGRERR_NOT_ENOUGH_DATA, /**< Not enough data to deserialize */ + OGRERR_NOT_ENOUGH_MEMORY, /**< Not enough memory */ + OGRERR_UNSUPPORTED_GEOMETRY_TYPE, /**< Unsupported geometry type */ + OGRERR_UNSUPPORTED_OPERATION, /**< Unsupported operation */ + OGRERR_CORRUPT_DATA, /**< Corrupt data */ + OGRERR_FAILURE, /**< Failure */ + OGRERR_UNSUPPORTED_SRS, /**< Unsupported SRS */ + OGRERR_INVALID_HANDLE, /**< Invalid handle */ + OGRERR_NON_EXISTING_FEATURE /**< Non existing feature. Added in GDAL 2.0 */ +} OGRErr; + +/** + *
+ */ +typedef enum +{ + /** + *
+ * + * Should see PASS below. + */ + FAIL, + /** + *
+ * + * Should see OGRERR_NONE instead of CUSTOM_OGRERR_NONE below. + */ + CUSTOM_OGRERR_NONE +} StrictOGRErr; diff --git a/bindgen-tests/tests/headers/enum.h b/bindgen-tests/tests/headers/enum.h new file mode 100644 index 0000000000..0147433ee9 --- /dev/null +++ b/bindgen-tests/tests/headers/enum.h @@ -0,0 +1,31 @@ +// A few tests for enum-related issues that should be tested with all the enum +// representations. + +struct foo { + enum { + FOO_A, + FOO_B, + } member; +}; + +enum Foo { + Bar = 0, + Qux +}; + +enum Neg { + MinusOne = -1, + One = 1, +}; + +/**
*/ +enum NoDebug { + NoDebug1, + NoDebug2, +}; + +/**
*/ +enum Debug { + Debug1, + Debug2, +}; \ No newline at end of file diff --git a/bindgen-tests/tests/headers/enum_alias.hpp b/bindgen-tests/tests/headers/enum_alias.hpp new file mode 100644 index 0000000000..8ddb25c36c --- /dev/null +++ b/bindgen-tests/tests/headers/enum_alias.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --rustified-enum ".*" -- -std=c++11 + +typedef unsigned char uint8_t; + +enum Bar : uint8_t { + VAL +}; diff --git a/bindgen-tests/tests/headers/enum_and_vtable_mangling.hpp b/bindgen-tests/tests/headers/enum_and_vtable_mangling.hpp new file mode 100644 index 0000000000..659a8bd1d6 --- /dev/null +++ b/bindgen-tests/tests/headers/enum_and_vtable_mangling.hpp @@ -0,0 +1,12 @@ +// bindgen-flags: --rustified-enum ".*" + +enum { + match, + whatever_else, +}; + +class C { + int i; +public: + virtual void match(); +}; diff --git a/bindgen-tests/tests/headers/enum_dupe.h b/bindgen-tests/tests/headers/enum_dupe.h new file mode 100644 index 0000000000..b8d9689aa8 --- /dev/null +++ b/bindgen-tests/tests/headers/enum_dupe.h @@ -0,0 +1,6 @@ +// bindgen-flags: --rustified-enum ".*" + +enum Foo { + Bar = 1, + Dupe = 1 +}; diff --git a/bindgen-tests/tests/headers/enum_explicit_type.hpp b/bindgen-tests/tests/headers/enum_explicit_type.hpp new file mode 100644 index 0000000000..38e636e6c2 --- /dev/null +++ b/bindgen-tests/tests/headers/enum_explicit_type.hpp @@ -0,0 +1,42 @@ +// bindgen-flags: --rustified-enum ".*" -- -std=c++11 + +enum Foo: unsigned char { + Bar = 0, + Qux +}; + +enum Neg: signed char { + MinusOne = -1, + One = 1, +}; + +enum Bigger: unsigned short { + Much = 255, + Larger +}; + +enum MuchLong: long { + MuchLow = -4294967296, +}; + +enum MuchLongLong: long long { + I64_MIN = 1ll << 63, +}; + +enum MuchULongLong: unsigned long long { + MuchHigh = 4294967296, +}; + +enum BoolEnumsAreFun: bool { + Value = true, +}; + +using MyType = bool; +enum BoolEnumsAreFun2: MyType { + Value2 = true, +}; + +enum : unsigned char { + AnonymousVariantOne, + AnonymousVariantTwo, +}; diff --git a/bindgen-tests/tests/headers/enum_explicit_type_constants.hpp b/bindgen-tests/tests/headers/enum_explicit_type_constants.hpp new file mode 100644 index 0000000000..e1ecf6fa8d --- /dev/null +++ b/bindgen-tests/tests/headers/enum_explicit_type_constants.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: --raw-line '#![cfg(not(target_os="windows"))]' -- -std=c++11 +// +// This test is much like enum_explicit_type, but without --rustified-enum. + +#include "enum_explicit_type.hpp" diff --git a/bindgen-tests/tests/headers/enum_in_template.hpp b/bindgen-tests/tests/headers/enum_in_template.hpp new file mode 100644 index 0000000000..41c017c4bc --- /dev/null +++ b/bindgen-tests/tests/headers/enum_in_template.hpp @@ -0,0 +1,10 @@ + +template +class Foo +{ + enum Bar + { + A, + B + }; +}; diff --git a/bindgen-tests/tests/headers/enum_in_template_with_typedef.hpp b/bindgen-tests/tests/headers/enum_in_template_with_typedef.hpp new file mode 100644 index 0000000000..87290ecec6 --- /dev/null +++ b/bindgen-tests/tests/headers/enum_in_template_with_typedef.hpp @@ -0,0 +1,16 @@ +// bindgen-flags: --rustified-enum ".*" -- -std=c++11 + +namespace std { + template class fbstring_core; +} + +typedef unsigned char uint8_t; +namespace std { + template class fbstring_core { + typedef uint8_t category_type; + enum Category : category_type { + Foo = 1, + Bar = 4, + }; + }; +} diff --git a/bindgen-tests/tests/headers/enum_negative.h b/bindgen-tests/tests/headers/enum_negative.h new file mode 100644 index 0000000000..0fa0df9712 --- /dev/null +++ b/bindgen-tests/tests/headers/enum_negative.h @@ -0,0 +1,6 @@ +// bindgen-flags: --rustified-enum ".*" + +enum Foo { + Bar = -2, + Qux = 1, +}; diff --git a/tests/headers/enum_packed.h b/bindgen-tests/tests/headers/enum_packed.h similarity index 82% rename from tests/headers/enum_packed.h rename to bindgen-tests/tests/headers/enum_packed.h index 8654d110fd..cc70c816d8 100644 --- a/tests/headers/enum_packed.h +++ b/bindgen-tests/tests/headers/enum_packed.h @@ -1,3 +1,5 @@ +// bindgen-flags: --rustified-enum ".*" + enum __attribute__((packed)) Foo { Bar = 0, Qux diff --git a/bindgen-tests/tests/headers/error-E0600-cannot-apply-unary-negation-to-u32.h b/bindgen-tests/tests/headers/error-E0600-cannot-apply-unary-negation-to-u32.h new file mode 100644 index 0000000000..4c342c0ec5 --- /dev/null +++ b/bindgen-tests/tests/headers/error-E0600-cannot-apply-unary-negation-to-u32.h @@ -0,0 +1,5 @@ +// bindgen-flags: --raw-line "#![allow(overflowing_literals)]" + +typedef unsigned int uint32_t; + +uint32_t a = 18446744073709551611; diff --git a/bindgen-tests/tests/headers/eval-value-dependent.hpp b/bindgen-tests/tests/headers/eval-value-dependent.hpp new file mode 100644 index 0000000000..0f4dc6ab25 --- /dev/null +++ b/bindgen-tests/tests/headers/eval-value-dependent.hpp @@ -0,0 +1,6 @@ +// bindgen-flags: -- -std=c++11 + +template class e { + using f = d; + static const auto g = alignof(f); +}; diff --git a/bindgen-tests/tests/headers/eval-variadic-template-parameter.hpp b/bindgen-tests/tests/headers/eval-variadic-template-parameter.hpp new file mode 100644 index 0000000000..0a9e51c1e3 --- /dev/null +++ b/bindgen-tests/tests/headers/eval-variadic-template-parameter.hpp @@ -0,0 +1,8 @@ +// bindgen-flags: -- -std=c++11 + +template +struct B { + // Can't generate anything meaningful in Rust for this, but we shouldn't + // trigger an assertion inside Clang. + static const long c = sizeof...(T); +}; diff --git a/bindgen-tests/tests/headers/explicit-padding.h b/bindgen-tests/tests/headers/explicit-padding.h new file mode 100644 index 0000000000..4abaafba9b --- /dev/null +++ b/bindgen-tests/tests/headers/explicit-padding.h @@ -0,0 +1,17 @@ +// bindgen-flags: --explicit-padding + +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; + +struct pad_me { + uint8_t first; + uint32_t second; + uint16_t third; +}; + +union dont_pad_me { + uint8_t first; + uint32_t second; + uint16_t third; +}; diff --git a/bindgen-tests/tests/headers/extern-const-struct.h b/bindgen-tests/tests/headers/extern-const-struct.h new file mode 100644 index 0000000000..10006e8284 --- /dev/null +++ b/bindgen-tests/tests/headers/extern-const-struct.h @@ -0,0 +1,5 @@ +struct nsFoo { + float details[400]; +}; + +extern const struct nsFoo gDetails; diff --git a/bindgen-tests/tests/headers/extern-fn-block-attrs-many.h b/bindgen-tests/tests/headers/extern-fn-block-attrs-many.h new file mode 100644 index 0000000000..0de6eebb36 --- /dev/null +++ b/bindgen-tests/tests/headers/extern-fn-block-attrs-many.h @@ -0,0 +1,3 @@ +// bindgen-flags: --extern-fn-block-attrs '#[allow(dead_code)]' --extern-fn-block-attrs '#[cfg_attr(not(windows), link(wasm_import_module = "test-module"))]' + +void test_function(); \ No newline at end of file diff --git a/bindgen-tests/tests/headers/extern-fn-block-attrs-wasm.h b/bindgen-tests/tests/headers/extern-fn-block-attrs-wasm.h new file mode 100644 index 0000000000..2f475f1ed1 --- /dev/null +++ b/bindgen-tests/tests/headers/extern-fn-block-attrs-wasm.h @@ -0,0 +1,3 @@ +// bindgen-flags: --extern-fn-block-attrs '#[allow(dead_code)]' --wasm-import-module-name test-module + +void test_function(); \ No newline at end of file diff --git a/bindgen-tests/tests/headers/extern-fn-block-attrs.h b/bindgen-tests/tests/headers/extern-fn-block-attrs.h new file mode 100644 index 0000000000..26480e2ef0 --- /dev/null +++ b/bindgen-tests/tests/headers/extern-fn-block-attrs.h @@ -0,0 +1,3 @@ +// bindgen-flags: --extern-fn-block-attrs '#[allow(dead_code)]' + +void test_function(); \ No newline at end of file diff --git a/tests/headers/extern.hpp b/bindgen-tests/tests/headers/extern.hpp similarity index 100% rename from tests/headers/extern.hpp rename to bindgen-tests/tests/headers/extern.hpp diff --git a/bindgen-tests/tests/headers/extern_blocks_post_1_82.h b/bindgen-tests/tests/headers/extern_blocks_post_1_82.h new file mode 100644 index 0000000000..f7f3464e98 --- /dev/null +++ b/bindgen-tests/tests/headers/extern_blocks_post_1_82.h @@ -0,0 +1,5 @@ +// bindgen-flags: --no-layout-tests --rust-target=1.82 + +void cool_function(int i, char c); + +static int cool_static; diff --git a/bindgen-tests/tests/headers/extern_blocks_pre_1_82.h b/bindgen-tests/tests/headers/extern_blocks_pre_1_82.h new file mode 100644 index 0000000000..604625a0a3 --- /dev/null +++ b/bindgen-tests/tests/headers/extern_blocks_pre_1_82.h @@ -0,0 +1,5 @@ +// bindgen-flags: --no-layout-tests + +void cool_function(int i, char c); + +static int cool_static; diff --git a/bindgen-tests/tests/headers/field-visibility-callback.h b/bindgen-tests/tests/headers/field-visibility-callback.h new file mode 100644 index 0000000000..d2fe3ace80 --- /dev/null +++ b/bindgen-tests/tests/headers/field-visibility-callback.h @@ -0,0 +1,9 @@ +// bindgen-flags: --default-visibility private +// bindgen-parse-callbacks: field-visibility-default-private + +struct my_struct { + int a; + int private_b; + int c: 1; + int private_d: 1; +}; diff --git a/bindgen-tests/tests/headers/field-visibility.h b/bindgen-tests/tests/headers/field-visibility.h new file mode 100644 index 0000000000..adb73159c2 --- /dev/null +++ b/bindgen-tests/tests/headers/field-visibility.h @@ -0,0 +1,10 @@ +// bindgen-flags: --default-visibility private --no-doc-comments + +struct my_struct1 { + int a: 1; +}; + +/**
*/ +struct my_struct2 { + int a: 1; +}; diff --git a/bindgen-tests/tests/headers/fit-macro-constant-types-signed.h b/bindgen-tests/tests/headers/fit-macro-constant-types-signed.h new file mode 100644 index 0000000000..dba20937df --- /dev/null +++ b/bindgen-tests/tests/headers/fit-macro-constant-types-signed.h @@ -0,0 +1,2 @@ +// bindgen-flags: --default-macro-constant-type=signed --fit-macro-constant-types +#include "default-macro-constant-type.h" diff --git a/bindgen-tests/tests/headers/fit-macro-constant-types.h b/bindgen-tests/tests/headers/fit-macro-constant-types.h new file mode 100644 index 0000000000..b995bfc0d4 --- /dev/null +++ b/bindgen-tests/tests/headers/fit-macro-constant-types.h @@ -0,0 +1,4 @@ +// bindgen-flags: --fit-macro-constant-types +// Test fitting macro constants into smaller integer types +// Negative values are i8, i16, i32 or i64; others are u8, u16, u32 or u64. +#include "default-macro-constant-type.h" \ No newline at end of file diff --git a/bindgen-tests/tests/headers/flexarray.hpp b/bindgen-tests/tests/headers/flexarray.hpp new file mode 100644 index 0000000000..b698c38d19 --- /dev/null +++ b/bindgen-tests/tests/headers/flexarray.hpp @@ -0,0 +1,32 @@ +// bindgen-flags: --rust-target nightly --flexarray-dst --raw-line '#![cfg(feature = "nightly")]' --raw-line '#![feature(ptr_metadata, layout_for_ptr)]' + +struct flexarray { + int count; + int data[]; +}; + +struct flexarray_zero { + int count; + int data[0]; +}; + +template +struct flexarray_template { + int count; + T data[]; +}; + +struct flexarray_ref { + flexarray *things; +}; + +struct flexarray_bogus_zero_fam { + int count; + int data1[0]; + char data2[]; +}; + +struct flexarray_align { + int count; + int data[]; +} __attribute__((aligned(128))); diff --git a/bindgen-tests/tests/headers/float128.hpp b/bindgen-tests/tests/headers/float128.hpp new file mode 100644 index 0000000000..f554e88e1a --- /dev/null +++ b/bindgen-tests/tests/headers/float128.hpp @@ -0,0 +1,13 @@ +// FIXME: libclang < 3.9 does not expose `__float128` in its interface, so this +// test will fail. Once we remove support for `--features llvm_stable` and +// require libclang >= 3.9, we can reenable this test. +// +// static __float128 global = 1.0; + +// FIXME: We have no way to get 128 bit aligned structs in Rust at the moment, +// and therefore the generated layout tests for this struct will fail. When we +// can enforce 128 bit alignment, we can re-enable this test. +// +// struct A { +// __float128 f; +// }; diff --git a/bindgen-tests/tests/headers/float16.h b/bindgen-tests/tests/headers/float16.h new file mode 100644 index 0000000000..3b1058591d --- /dev/null +++ b/bindgen-tests/tests/headers/float16.h @@ -0,0 +1,36 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq + +static __fp16 global; + +struct Test__Float16 +{ + __fp16 f; +}; + +struct Test__Float16Ref +{ + __fp16 *f; +}; + +/* +// This options are currently supported only on specific targets (eg. x86 with sse2) +_Float16 returns_f16(); + +void gets_f16(_Float16 arg); + +struct Test__Float16_Complex +{ + _Float16 _Complex mMember; +}; + +struct Test__Float16_ComplexPtr +{ + _Float16 _Complex *mMember; +}; + +_Float16 _Complex globalValueHalf; + +_Float16 _Complex returns_f16_complex(); + +void gets_f16_complex(_Float16 _Complex arg); +*/ \ No newline at end of file diff --git a/bindgen-tests/tests/headers/forward-declaration-autoptr.hpp b/bindgen-tests/tests/headers/forward-declaration-autoptr.hpp new file mode 100644 index 0000000000..a26c1cd2eb --- /dev/null +++ b/bindgen-tests/tests/headers/forward-declaration-autoptr.hpp @@ -0,0 +1,10 @@ +class Foo; + +template +struct RefPtr { + T* m_inner; +}; + +struct Bar { + RefPtr m_member; +}; diff --git a/bindgen-tests/tests/headers/forward-enum-decl.hpp b/bindgen-tests/tests/headers/forward-enum-decl.hpp new file mode 100644 index 0000000000..81a0eee731 --- /dev/null +++ b/bindgen-tests/tests/headers/forward-enum-decl.hpp @@ -0,0 +1,8 @@ +// bindgen-flags: --rustified-enum ".*" -- -std=c++11 + +enum class CSSPseudoClassType : int; + +enum class CSSPseudoClassType : int { + empty, + link, +}; diff --git a/bindgen-tests/tests/headers/forward-inherit-struct-with-fields.hpp b/bindgen-tests/tests/headers/forward-inherit-struct-with-fields.hpp new file mode 100644 index 0000000000..437fff5d62 --- /dev/null +++ b/bindgen-tests/tests/headers/forward-inherit-struct-with-fields.hpp @@ -0,0 +1,8 @@ +template class Rooted; +namespace js { + template class RootedBase { + T* foo; + Rooted* next; + }; +} +template class Rooted : js::RootedBase {}; diff --git a/bindgen-tests/tests/headers/forward-inherit-struct.hpp b/bindgen-tests/tests/headers/forward-inherit-struct.hpp new file mode 100644 index 0000000000..ac7aef5ee0 --- /dev/null +++ b/bindgen-tests/tests/headers/forward-inherit-struct.hpp @@ -0,0 +1,5 @@ +template class Rooted; +namespace js { + template class RootedBase {}; +} +template class Rooted : js::RootedBase {}; diff --git a/bindgen-tests/tests/headers/forward_declared_complex_types.hpp b/bindgen-tests/tests/headers/forward_declared_complex_types.hpp new file mode 100644 index 0000000000..ffc779adec --- /dev/null +++ b/bindgen-tests/tests/headers/forward_declared_complex_types.hpp @@ -0,0 +1,16 @@ +struct Foo_empty {}; +struct Foo; + +struct Bar { + Foo *f; +}; + +void baz_struct(Foo* f); + +union Union; + +void baz_union(Union* u); + +class Quux; + +void baz_class(Quux* q); diff --git a/bindgen-tests/tests/headers/forward_declared_opaque.h b/bindgen-tests/tests/headers/forward_declared_opaque.h new file mode 100644 index 0000000000..69a12cc7e2 --- /dev/null +++ b/bindgen-tests/tests/headers/forward_declared_opaque.h @@ -0,0 +1,4 @@ +// bindgen-flags: --opaque-type ".*" + +union a; +struct b; diff --git a/tests/headers/forward_declared_struct.h b/bindgen-tests/tests/headers/forward_declared_struct.h similarity index 100% rename from tests/headers/forward_declared_struct.h rename to bindgen-tests/tests/headers/forward_declared_struct.h diff --git a/tests/headers/func_proto.h b/bindgen-tests/tests/headers/func_proto.h similarity index 100% rename from tests/headers/func_proto.h rename to bindgen-tests/tests/headers/func_proto.h diff --git a/bindgen-tests/tests/headers/func_ptr.h b/bindgen-tests/tests/headers/func_ptr.h new file mode 100644 index 0000000000..34dc48d129 --- /dev/null +++ b/bindgen-tests/tests/headers/func_ptr.h @@ -0,0 +1,3 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +int (*foo) (int x, int y); diff --git a/bindgen-tests/tests/headers/func_ptr_in_struct.h b/bindgen-tests/tests/headers/func_ptr_in_struct.h new file mode 100644 index 0000000000..ef075df76c --- /dev/null +++ b/bindgen-tests/tests/headers/func_ptr_in_struct.h @@ -0,0 +1,7 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*" +// +enum baz; + +struct Foo { + enum baz (*bar) (int x, int y); +}; diff --git a/bindgen-tests/tests/headers/func_ptr_return_type.h b/bindgen-tests/tests/headers/func_ptr_return_type.h new file mode 100644 index 0000000000..d529edc770 --- /dev/null +++ b/bindgen-tests/tests/headers/func_ptr_return_type.h @@ -0,0 +1 @@ +int (*func(void))(int, int); diff --git a/bindgen-tests/tests/headers/func_return_must_use.h b/bindgen-tests/tests/headers/func_return_must_use.h new file mode 100644 index 0000000000..f05bd2de40 --- /dev/null +++ b/bindgen-tests/tests/headers/func_return_must_use.h @@ -0,0 +1,36 @@ +// bindgen-flags: --must-use-type 'MustUse.*' + +typedef int MustUseInt; + +MustUseInt return_int(); + +struct MustUseStruct; + +struct MustUseStruct return_struct(); + +/** + *
+ */ +typedef int AnnotatedInt; + +AnnotatedInt return_annotated_int(); + +int return_plain_int(); + +/** + *
+ */ +struct AnnotatedStruct {}; + +struct AnnotatedStruct return_annotated_struct(); + +struct PlainStruct {}; + +/** + *
+ */ +typedef struct PlainStruct TypedefPlainStruct; + +struct PlainStruct return_plain_struct(); + +TypedefPlainStruct return_typedef_struct(); diff --git a/tests/headers/func_with_array_arg.h b/bindgen-tests/tests/headers/func_with_array_arg.h similarity index 100% rename from tests/headers/func_with_array_arg.h rename to bindgen-tests/tests/headers/func_with_array_arg.h diff --git a/bindgen-tests/tests/headers/func_with_func_ptr_arg.h b/bindgen-tests/tests/headers/func_with_func_ptr_arg.h new file mode 100644 index 0000000000..e9abcae688 --- /dev/null +++ b/bindgen-tests/tests/headers/func_with_func_ptr_arg.h @@ -0,0 +1,3 @@ +void foo(void (*bar)()); + +void bar(void (*one)(int a, int b), void (*two)(int c, int d)); diff --git a/bindgen-tests/tests/headers/function-typedef-stdcall.h b/bindgen-tests/tests/headers/function-typedef-stdcall.h new file mode 100644 index 0000000000..05d1e78a26 --- /dev/null +++ b/bindgen-tests/tests/headers/function-typedef-stdcall.h @@ -0,0 +1,12 @@ +typedef + void __stdcall + EVT_VIGEM_X360_NOTIFICATION( + void* Client, + void* Target, + unsigned char LargeMotor, + unsigned char SmallMotor, + unsigned char LedNumber, + void* UserData + ); + +typedef EVT_VIGEM_X360_NOTIFICATION *PFN_VIGEM_X360_NOTIFICATION; diff --git a/bindgen-tests/tests/headers/gen-constructors-neg.hpp b/bindgen-tests/tests/headers/gen-constructors-neg.hpp new file mode 100644 index 0000000000..2dd491c4fd --- /dev/null +++ b/bindgen-tests/tests/headers/gen-constructors-neg.hpp @@ -0,0 +1,6 @@ +// bindgen-flags: --generate types,functions + +class Foo { + public: + Foo(int a); +}; diff --git a/bindgen-tests/tests/headers/gen-constructors.hpp b/bindgen-tests/tests/headers/gen-constructors.hpp new file mode 100644 index 0000000000..809d6ef998 --- /dev/null +++ b/bindgen-tests/tests/headers/gen-constructors.hpp @@ -0,0 +1,6 @@ +// bindgen-flags: --generate types,constructors,functions + +class Foo { + public: + Foo(int a); +}; diff --git a/bindgen-tests/tests/headers/gen-destructors-neg.hpp b/bindgen-tests/tests/headers/gen-destructors-neg.hpp new file mode 100644 index 0000000000..5ede3ba357 --- /dev/null +++ b/bindgen-tests/tests/headers/gen-destructors-neg.hpp @@ -0,0 +1,9 @@ +// bindgen-flags: --generate types,functions +// +// NB: This is intended to _not_ generate destructors. + +class Foo { + int bar; + public: + ~Foo(); +}; diff --git a/bindgen-tests/tests/headers/gen-destructors.hpp b/bindgen-tests/tests/headers/gen-destructors.hpp new file mode 100644 index 0000000000..719eb248a9 --- /dev/null +++ b/bindgen-tests/tests/headers/gen-destructors.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --generate types,destructors,functions + +class Foo { + int bar; + public: + ~Foo(); +}; diff --git a/bindgen-tests/tests/headers/generate-inline.hpp b/bindgen-tests/tests/headers/generate-inline.hpp new file mode 100644 index 0000000000..922ee1ca7c --- /dev/null +++ b/bindgen-tests/tests/headers/generate-inline.hpp @@ -0,0 +1,12 @@ +// bindgen-flags: --generate-inline-functions + +class Foo { + public: + static inline int bar() { + return 42; + } +}; + +inline int foo() { + return 42; +} diff --git a/bindgen-tests/tests/headers/i128.h b/bindgen-tests/tests/headers/i128.h new file mode 100644 index 0000000000..1880f11305 --- /dev/null +++ b/bindgen-tests/tests/headers/i128.h @@ -0,0 +1,4 @@ +struct foo { + __int128 my_signed; + unsigned __int128 my_unsigned; +}; diff --git a/tests/headers/in_class_typedef.hpp b/bindgen-tests/tests/headers/in_class_typedef.hpp similarity index 100% rename from tests/headers/in_class_typedef.hpp rename to bindgen-tests/tests/headers/in_class_typedef.hpp diff --git a/bindgen-tests/tests/headers/incomplete-array-padding.h b/bindgen-tests/tests/headers/incomplete-array-padding.h new file mode 100644 index 0000000000..3fcc4c1a09 --- /dev/null +++ b/bindgen-tests/tests/headers/incomplete-array-padding.h @@ -0,0 +1,4 @@ +struct foo { + char a : 1; + void *b[]; +}; diff --git a/bindgen-tests/tests/headers/infinite-macro.hpp b/bindgen-tests/tests/headers/infinite-macro.hpp new file mode 100644 index 0000000000..32c8b61911 --- /dev/null +++ b/bindgen-tests/tests/headers/infinite-macro.hpp @@ -0,0 +1,7 @@ +#define INFINITY (1.0f/0.0f) +#define NEG_INFINITY (-1.0f/0.0f) +#define NAN (0.0f/0.0f) + +static const float F32_INFINITY = 1.0f / 0.0f; +static const float F32_NEG_INFINITY = -1.0f / 0.0f; +static const float F32_NAN = 0.0f / 0.0f; diff --git a/bindgen-tests/tests/headers/inherit-from-template-instantiation-with-vtable.hpp b/bindgen-tests/tests/headers/inherit-from-template-instantiation-with-vtable.hpp new file mode 100644 index 0000000000..562ca0e1b2 --- /dev/null +++ b/bindgen-tests/tests/headers/inherit-from-template-instantiation-with-vtable.hpp @@ -0,0 +1,37 @@ +// bindgen-flags: -- -std=c++14 + +// Small test that we handle virtual tables correctly when deriving from a +// template instantiation. This wasn't previously handled at all. Note that when +// inheriting from a template parameter, the type that is instantiated might or +// might not have a virtual table, and we have no way of knowing. We don't +// handle that yet, so no test for it here. + +/// This should have an explicit vtable. +template +class BaseWithVtable { + T t; + + virtual void hello(); +}; + +/// This should not have an explicit vtable. +class DerivedWithNoVirtualMethods : public BaseWithVtable {}; + +/// This should not have an explicit vtable. +class DerivedWithVirtualMethods : public BaseWithVtable { + virtual void zoidberg(); +}; + +/// This should not have any vtable. +template +class BaseWithoutVtable { + U u; +}; + +/// This should have an explicit vtable. +class DerivedWithVtable : public BaseWithoutVtable { + virtual void leela(); +}; + +/// This should not have any vtable. +class DerivedWithoutVtable : public BaseWithoutVtable {}; diff --git a/bindgen-tests/tests/headers/inherit-namespaced.hpp b/bindgen-tests/tests/headers/inherit-namespaced.hpp new file mode 100644 index 0000000000..61eafd5a57 --- /dev/null +++ b/bindgen-tests/tests/headers/inherit-namespaced.hpp @@ -0,0 +1,4 @@ +namespace js { + template class RootedBase {}; +} +template class Rooted : js::RootedBase {}; diff --git a/bindgen-tests/tests/headers/inherit_multiple_interfaces.hpp b/bindgen-tests/tests/headers/inherit_multiple_interfaces.hpp new file mode 100644 index 0000000000..725992c7cd --- /dev/null +++ b/bindgen-tests/tests/headers/inherit_multiple_interfaces.hpp @@ -0,0 +1,15 @@ +class A { + virtual void Foo(); + + int member; +}; + +class B { + virtual void Bar(); + + void* member2; +}; + +class C : public A, public B { + float member3; +}; diff --git a/tests/headers/inherit_named.hpp b/bindgen-tests/tests/headers/inherit_named.hpp similarity index 100% rename from tests/headers/inherit_named.hpp rename to bindgen-tests/tests/headers/inherit_named.hpp diff --git a/tests/headers/inherit_typedef.hpp b/bindgen-tests/tests/headers/inherit_typedef.hpp similarity index 100% rename from tests/headers/inherit_typedef.hpp rename to bindgen-tests/tests/headers/inherit_typedef.hpp diff --git a/bindgen-tests/tests/headers/inline-function.h b/bindgen-tests/tests/headers/inline-function.h new file mode 100644 index 0000000000..02cb7c08ab --- /dev/null +++ b/bindgen-tests/tests/headers/inline-function.h @@ -0,0 +1,6 @@ +// bindgen-unstable + +/** The point of this test is to _not_ generate these functions. */ + +inline static int myadd(const int x, const int y) { return x + y; } +static int mysub(const int x, const int y) { return x - y; } diff --git a/bindgen-tests/tests/headers/inline_namespace.hpp b/bindgen-tests/tests/headers/inline_namespace.hpp new file mode 100644 index 0000000000..2ccf8ab0e2 --- /dev/null +++ b/bindgen-tests/tests/headers/inline_namespace.hpp @@ -0,0 +1,11 @@ +// bindgen-flags: --enable-cxx-namespaces -- -std=c++11 + +namespace foo { + inline namespace bar { + using Ty = int; + }; +}; + +class Bar { + foo::Ty baz; +}; diff --git a/bindgen-tests/tests/headers/inline_namespace_allowlist.hpp b/bindgen-tests/tests/headers/inline_namespace_allowlist.hpp new file mode 100644 index 0000000000..90e46dfb84 --- /dev/null +++ b/bindgen-tests/tests/headers/inline_namespace_allowlist.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --enable-cxx-namespaces --allowlist-type=std::string -- -std=c++11 + +namespace std { + inline namespace bar { + using string = const char*; + }; +}; diff --git a/bindgen-tests/tests/headers/inline_namespace_conservative.hpp b/bindgen-tests/tests/headers/inline_namespace_conservative.hpp new file mode 100644 index 0000000000..50068a2e0a --- /dev/null +++ b/bindgen-tests/tests/headers/inline_namespace_conservative.hpp @@ -0,0 +1,12 @@ +// bindgen-flags: --enable-cxx-namespaces --conservative-inline-namespaces -- -std=c++11 + +namespace foo { + inline namespace bar { + using Ty = int; + }; + using Ty = long long; +}; + +class Bar { + foo::bar::Ty baz; +}; diff --git a/bindgen-tests/tests/headers/inline_namespace_macro.hpp b/bindgen-tests/tests/headers/inline_namespace_macro.hpp new file mode 100644 index 0000000000..c7cf5caf98 --- /dev/null +++ b/bindgen-tests/tests/headers/inline_namespace_macro.hpp @@ -0,0 +1,9 @@ +// bindgen-flags: --enable-cxx-namespaces -- -std=c++11 + +#include "namespace/nsdefine.h" + +BEGIN_NAMESPACE + +class duration {}; + +END_NAMESPACE diff --git a/bindgen-tests/tests/headers/inline_namespace_nested.hpp b/bindgen-tests/tests/headers/inline_namespace_nested.hpp new file mode 100644 index 0000000000..5c542e195c --- /dev/null +++ b/bindgen-tests/tests/headers/inline_namespace_nested.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: --enable-cxx-namespaces -- -std=c++2a + +namespace ranges::inline foo::bar { + static int bar = 0; +} diff --git a/bindgen-tests/tests/headers/inline_namespace_no_ns_enabled.hpp b/bindgen-tests/tests/headers/inline_namespace_no_ns_enabled.hpp new file mode 100644 index 0000000000..30cd4e9b86 --- /dev/null +++ b/bindgen-tests/tests/headers/inline_namespace_no_ns_enabled.hpp @@ -0,0 +1,18 @@ +// bindgen-flags: -- -std=c++11 + +namespace std { +inline namespace __cxx11 { + +template +class basic_string { + struct Alloc_hider { + void* storage; + } hider; + unsigned long length; + struct { + CharT inline_storage[4]; + }; +}; + +} +} diff --git a/bindgen-tests/tests/headers/inner-typedef-gh422.hpp b/bindgen-tests/tests/headers/inner-typedef-gh422.hpp new file mode 100644 index 0000000000..301630a5e0 --- /dev/null +++ b/bindgen-tests/tests/headers/inner-typedef-gh422.hpp @@ -0,0 +1,11 @@ +template +class Foo { +public: + class InnerType { + T t; + }; +}; + +typedef Foo::InnerType Bar; + +Bar func(); \ No newline at end of file diff --git a/tests/headers/inner_const.hpp b/bindgen-tests/tests/headers/inner_const.hpp similarity index 100% rename from tests/headers/inner_const.hpp rename to bindgen-tests/tests/headers/inner_const.hpp diff --git a/tests/headers/inner_template_self.hpp b/bindgen-tests/tests/headers/inner_template_self.hpp similarity index 100% rename from tests/headers/inner_template_self.hpp rename to bindgen-tests/tests/headers/inner_template_self.hpp diff --git a/tests/headers/int128_t.h b/bindgen-tests/tests/headers/int128_t.h similarity index 100% rename from tests/headers/int128_t.h rename to bindgen-tests/tests/headers/int128_t.h diff --git a/bindgen-tests/tests/headers/issue-1025-unknown-enum-repr.hpp b/bindgen-tests/tests/headers/issue-1025-unknown-enum-repr.hpp new file mode 100644 index 0000000000..589b3c25f3 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1025-unknown-enum-repr.hpp @@ -0,0 +1,4 @@ + +template class a { + enum {}; +}; diff --git a/bindgen-tests/tests/headers/issue-1034.h b/bindgen-tests/tests/headers/issue-1034.h new file mode 100644 index 0000000000..8042fec60f --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1034.h @@ -0,0 +1,4 @@ + +struct S2 { + unsigned : 11 +}; diff --git a/bindgen-tests/tests/headers/issue-1040.h b/bindgen-tests/tests/headers/issue-1040.h new file mode 100644 index 0000000000..1d61d40d2b --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1040.h @@ -0,0 +1 @@ +unsigned long long g_107 = 18446744073709551615UL; diff --git a/bindgen-tests/tests/headers/issue-1076-unnamed-bitfield-alignment.h b/bindgen-tests/tests/headers/issue-1076-unnamed-bitfield-alignment.h new file mode 100644 index 0000000000..876ec17489 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1076-unnamed-bitfield-alignment.h @@ -0,0 +1,4 @@ +struct S1 { + signed : 15; + unsigned : 6 +}; diff --git a/bindgen-tests/tests/headers/issue-1113-template-references.hpp b/bindgen-tests/tests/headers/issue-1113-template-references.hpp new file mode 100644 index 0000000000..46339c5dfe --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1113-template-references.hpp @@ -0,0 +1,16 @@ +template +class Entry : public K +{ + V mData; +}; + +template +class nsBaseHashtable { + typedef Entry EntryType; + + struct EntryPtr { + private: + EntryType& mEntry; + bool mExistingEntry; + }; +}; diff --git a/bindgen-tests/tests/headers/issue-1118-using-forward-decl.hpp b/bindgen-tests/tests/headers/issue-1118-using-forward-decl.hpp new file mode 100644 index 0000000000..b6ea63f69e --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1118-using-forward-decl.hpp @@ -0,0 +1,10 @@ +template class nsTArray; +template using c = nsTArray; +class nsTArray_base { + int *d; +}; +template class nsTArray : nsTArray_base {}; +class nsIContent { + nsTArray foo; +}; +nsTArray *Gecko_GetAnonymousContentForElement(); diff --git a/bindgen-tests/tests/headers/issue-1197-pure-virtual-stuff.hpp b/bindgen-tests/tests/headers/issue-1197-pure-virtual-stuff.hpp new file mode 100644 index 0000000000..a0da90c903 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1197-pure-virtual-stuff.hpp @@ -0,0 +1,6 @@ +class Foo +{ +public: + virtual void Bar() = 0; + virtual ~Foo() = 0; +}; diff --git a/bindgen-tests/tests/headers/issue-1198-alias-rust-bitfield-enum.h b/bindgen-tests/tests/headers/issue-1198-alias-rust-bitfield-enum.h new file mode 100644 index 0000000000..5bccb0d4c9 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1198-alias-rust-bitfield-enum.h @@ -0,0 +1,13 @@ +// bindgen-flags: --rustified-enum '.*' --bitfield-enum '.*' + +typedef enum MyDupeEnum { + A = 0, + A_alias = 0, + B, +} MyDupeEnum; + +enum MyOtherDupeEnum { + C = 0, + C_alias = 0, + D, +}; diff --git a/bindgen-tests/tests/headers/issue-1198-alias-rust-const-mod-bitfield-enum.h b/bindgen-tests/tests/headers/issue-1198-alias-rust-const-mod-bitfield-enum.h new file mode 100644 index 0000000000..ecdf8c3f24 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1198-alias-rust-const-mod-bitfield-enum.h @@ -0,0 +1,13 @@ +// bindgen-flags: --rustified-enum '.*' --constified-enum-module '.*' --bitfield-enum '.*' + +typedef enum MyDupeEnum { + A = 0, + A_alias = 0, + B, +} MyDupeEnum; + +enum MyOtherDupeEnum { + C = 0, + C_alias = 0, + D, +}; diff --git a/bindgen-tests/tests/headers/issue-1198-alias-rust-const-mod-enum.h b/bindgen-tests/tests/headers/issue-1198-alias-rust-const-mod-enum.h new file mode 100644 index 0000000000..944fac31b5 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1198-alias-rust-const-mod-enum.h @@ -0,0 +1,13 @@ +// bindgen-flags: --rustified-enum '.*' --constified-enum-module '.*' + +typedef enum MyDupeEnum { + A = 0, + A_alias = 0, + B, +} MyDupeEnum; + +enum MyOtherDupeEnum { + C = 0, + C_alias = 0, + D, +}; \ No newline at end of file diff --git a/bindgen-tests/tests/headers/issue-1198-alias-rust-enum.h b/bindgen-tests/tests/headers/issue-1198-alias-rust-enum.h new file mode 100644 index 0000000000..ede44f0a57 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1198-alias-rust-enum.h @@ -0,0 +1,14 @@ +// bindgen-flags: --rustified-enum '.*' + + +typedef enum MyDupeEnum { + A = 0, + A_alias = 0, + B, +} MyDupeEnum; + +enum MyOtherDupeEnum { + C = 0, + C_alias = 0, + D, +}; \ No newline at end of file diff --git a/bindgen-tests/tests/headers/issue-1216-variadic-member.h b/bindgen-tests/tests/headers/issue-1216-variadic-member.h new file mode 100644 index 0000000000..b8bc0b81db --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1216-variadic-member.h @@ -0,0 +1,4 @@ +void f(int a, ...); +struct Foo { + void (*f)(void *p, void *obj, int a, ...); +}; diff --git a/bindgen-tests/tests/headers/issue-1238-fwd-no-copy.h b/bindgen-tests/tests/headers/issue-1238-fwd-no-copy.h new file mode 100644 index 0000000000..150bbbeb77 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1238-fwd-no-copy.h @@ -0,0 +1,3 @@ +// bindgen-flags: --no-copy MyType + +typedef struct MyType MyTypeT; diff --git a/bindgen-tests/tests/headers/issue-1281.h b/bindgen-tests/tests/headers/issue-1281.h new file mode 100644 index 0000000000..4a3aaab0e5 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1281.h @@ -0,0 +1,11 @@ +struct foo; + +typedef struct bar { + struct foo { + int foo; + } u; +} bar_t; + +struct baz { + struct foo f; +}; diff --git a/bindgen-tests/tests/headers/issue-1285.h b/bindgen-tests/tests/headers/issue-1285.h new file mode 100644 index 0000000000..a2817d84b4 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1285.h @@ -0,0 +1,8 @@ +// bindgen-flags: --with-derive-hash --no-recursive-allowlist --allowlist-type "foo" + +struct foo { + union { + unsigned int a; + unsigned short b; + } bar; +}; \ No newline at end of file diff --git a/bindgen-tests/tests/headers/issue-1291.hpp b/bindgen-tests/tests/headers/issue-1291.hpp new file mode 100644 index 0000000000..cb4aeb91f8 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1291.hpp @@ -0,0 +1,20 @@ +// bindgen-unstable + +struct __attribute__((aligned(16))) RTCRay + { + float org[3]; + float align0; + float dir[3]; + float align1; + float tnear; + float tfar; + float time; + unsigned mask; + float Ng[3]; + float align2; + float u; + float v; + unsigned geomID; + unsigned primID; + unsigned instID; +}; diff --git a/bindgen-tests/tests/headers/issue-1350-attribute-overloadable.h b/bindgen-tests/tests/headers/issue-1350-attribute-overloadable.h new file mode 100644 index 0000000000..4b0ec2a6aa --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1350-attribute-overloadable.h @@ -0,0 +1,2 @@ +void my_function(int a) __attribute__((overloadable)); +void my_function(const char *a) __attribute__((overloadable)); diff --git a/bindgen-tests/tests/headers/issue-1375-prefixed-functions.h b/bindgen-tests/tests/headers/issue-1375-prefixed-functions.h new file mode 100644 index 0000000000..cc37c8ad80 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1375-prefixed-functions.h @@ -0,0 +1,8 @@ +// bindgen-parse-callbacks: remove-function-prefix-my_custom_prefix_ + +extern const int my_custom_prefix_var_const_name; + +extern int my_custom_prefix_var_mut_name; + +void my_custom_prefix_function_name(const int x); + diff --git a/bindgen-tests/tests/headers/issue-1382-rust-primitive-types.h b/bindgen-tests/tests/headers/issue-1382-rust-primitive-types.h new file mode 100644 index 0000000000..4cf346e6c9 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1382-rust-primitive-types.h @@ -0,0 +1,34 @@ +typedef int int8_t; +typedef int uint8_t; +typedef int int16_t; +typedef int uint16_t; +typedef int int32_t; +typedef int uint32_t; +typedef int int64_t; +typedef int uint64_t; + +typedef int8_t i8; +typedef uint8_t u8; +typedef int16_t i16; +typedef uint16_t u16; +typedef int32_t i32; +typedef uint32_t u32; +typedef int64_t i64; +typedef uint64_t u64; + +struct Foo { + int i8; + int u8; + int i16; + int u16; + int i32; + int u32; + int i64; + int u64; + int i128; + int u128; + int isize; + int usize; + int f32; + int f64; +}; diff --git a/bindgen-tests/tests/headers/issue-1435.hpp b/bindgen-tests/tests/headers/issue-1435.hpp new file mode 100644 index 0000000000..fbf3c5070b --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1435.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --enable-cxx-namespaces + +namespace ns { +enum class AB { A, B }; +} +using AB = ns::AB; +static const AB kA = AB::A; diff --git a/bindgen-tests/tests/headers/issue-1443.hpp b/bindgen-tests/tests/headers/issue-1443.hpp new file mode 100644 index 0000000000..9b637ba708 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1443.hpp @@ -0,0 +1,21 @@ +struct Foo; + +struct Bar { + const Foo& f; + unsigned m; +}; + +struct Baz { + Foo& f; + unsigned m; +}; + +struct Tar { + const Foo&& f; + unsigned m; +}; + +struct Taz { + Foo&& f; + unsigned m; +}; diff --git a/bindgen-tests/tests/headers/issue-1454.h b/bindgen-tests/tests/headers/issue-1454.h new file mode 100644 index 0000000000..96645dac9d --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1454.h @@ -0,0 +1,10 @@ +// bindgen-flags: --no-recursive-allowlist --allowlist-type "local_type" --with-derive-hash --no-derive-copy --no-derive-default --raw-line "#[repr(C)] #[derive(Debug)] pub struct extern_type;" +// bindgen-parse-callbacks: blocklisted-type-implements-trait + +struct extern_type {}; + +typedef struct +{ + struct extern_type inner; +} +local_type; diff --git a/bindgen-tests/tests/headers/issue-1464.hpp b/bindgen-tests/tests/headers/issue-1464.hpp new file mode 100644 index 0000000000..d34d0fe3e5 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1464.hpp @@ -0,0 +1,7 @@ + +// Should not crash. +template class Bar { +public: + Bar(); + ~Bar(); +}; diff --git a/bindgen-tests/tests/headers/issue-1488-enum-new-type.h b/bindgen-tests/tests/headers/issue-1488-enum-new-type.h new file mode 100644 index 0000000000..6855283ffb --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1488-enum-new-type.h @@ -0,0 +1,29 @@ +// bindgen-flags: --default-alias-style=new_type --constified-enum "Foo" --constified-enum-module "Bar" --rustified-enum "Qux" --new-type-alias-deref "BazAlias" + +enum Foo { + A, + B +}; + +typedef enum Foo FooAlias; + +enum Bar { + C, + D +}; + +typedef enum Bar BarAlias; + +enum Qux { + E, + F +}; + +typedef enum Qux QuxAlias; + +enum Baz { + G, + H +}; + +typedef enum Baz BazAlias; \ No newline at end of file diff --git a/bindgen-tests/tests/headers/issue-1488-options.h b/bindgen-tests/tests/headers/issue-1488-options.h new file mode 100644 index 0000000000..fba1c93bac --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1488-options.h @@ -0,0 +1,5 @@ +// bindgen-flags: --new-type-alias "SomePtr" --new-type-alias-deref "AnotherPtr" + +typedef int OSStatus; +typedef void* SomePtr; +typedef void* AnotherPtr; \ No newline at end of file diff --git a/bindgen-tests/tests/headers/issue-1488-template-alias-new-type.hpp b/bindgen-tests/tests/headers/issue-1488-template-alias-new-type.hpp new file mode 100644 index 0000000000..4374da3db2 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1488-template-alias-new-type.hpp @@ -0,0 +1,4 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --default-alias-style=new_type -- -std=c++14 + +template +using Wrapped = T; diff --git a/bindgen-tests/tests/headers/issue-1498.h b/bindgen-tests/tests/headers/issue-1498.h new file mode 100644 index 0000000000..aceabbd2b4 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1498.h @@ -0,0 +1,17 @@ +typedef unsigned long uint64_t; +typedef uint64_t size_t; +typedef unsigned uint32_t; +typedef int int32_t; + +struct rte_memseg { + uint64_t phys_addr; /**< Start physical address. */ + union { + void *addr; /**< Start virtual address. */ + uint64_t addr_64; /**< Makes sure addr is always 64 bits */ + }; + size_t len; /**< Length of the segment. */ + uint64_t hugepage_sz; /**< The pagesize of underlying memory */ + int32_t socket_id; /**< NUMA socket ID. */ + uint32_t nchannel; /**< Number of channels. */ + uint32_t nrank; /**< Number of ranks. */ +} __attribute__((__packed__)); diff --git a/bindgen-tests/tests/headers/issue-1514.hpp b/bindgen-tests/tests/headers/issue-1514.hpp new file mode 100644 index 0000000000..2a39889885 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1514.hpp @@ -0,0 +1,9 @@ +template +struct Thing { + struct Inner { + T *ptr; + }; + + struct AnotherInner : Inner { + }; +}; diff --git a/bindgen-tests/tests/headers/issue-1554.h b/bindgen-tests/tests/headers/issue-1554.h new file mode 100644 index 0000000000..13452923f8 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1554.h @@ -0,0 +1,6 @@ +// bindgen-flags: --default-enum-style rust_non_exhaustive --rust-target nightly --raw-line '#![cfg(feature = "nightly")]' --raw-line '#![feature(non_exhaustive)]' + +enum Planet { + earth, + mars +}; diff --git a/bindgen-tests/tests/headers/issue-1599-opaque-typedef-to-enum.h b/bindgen-tests/tests/headers/issue-1599-opaque-typedef-to-enum.h new file mode 100644 index 0000000000..85e845b85c --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1599-opaque-typedef-to-enum.h @@ -0,0 +1,3 @@ +// bindgen-flags: --opaque-type d + +typedef enum a { b, c } d; diff --git a/bindgen-tests/tests/headers/issue-1676-macro-namespace-prefix.hpp b/bindgen-tests/tests/headers/issue-1676-macro-namespace-prefix.hpp new file mode 100644 index 0000000000..297927b621 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1676-macro-namespace-prefix.hpp @@ -0,0 +1,2 @@ +#define nssv_inline_ns inline +nssv_inline_ns namespace literals {} diff --git a/bindgen-tests/tests/headers/issue-1947.h b/bindgen-tests/tests/headers/issue-1947.h new file mode 100644 index 0000000000..e2e9b3e19a --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1947.h @@ -0,0 +1,9 @@ +typedef unsigned char U8; +typedef unsigned short U16; + +typedef struct { + U16 MADZ : 10, MAI0 : 2, MAI1 : 2, MAI2 : 2; + U8 MADK, MABR; + U16 MATH : 10, MATE : 4, MATW : 2; + U8 MASW : 4, MABW : 3, MAXN : 1, _rB_; +} V56AMDY; diff --git a/bindgen-tests/tests/headers/issue-1977-larger-arrays.hpp b/bindgen-tests/tests/headers/issue-1977-larger-arrays.hpp new file mode 100644 index 0000000000..58e8e4d19a --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1977-larger-arrays.hpp @@ -0,0 +1,9 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +struct S { + char large_array[33]; +}; + +template struct ST { + T large_array[33]; +}; diff --git a/bindgen-tests/tests/headers/issue-1995.h b/bindgen-tests/tests/headers/issue-1995.h new file mode 100644 index 0000000000..619f673540 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-1995.h @@ -0,0 +1,12 @@ +/// This is a constant that has a docstring +/// +/// And expected to be found in generated bindings code too. +const int FOO = 1; + +/// This is a constant that has a docstring +/// +/// And expected to be found in generated bindings code too. +struct Bar +{ + int baz; +}; \ No newline at end of file diff --git a/bindgen-tests/tests/headers/issue-2019.hpp b/bindgen-tests/tests/headers/issue-2019.hpp new file mode 100644 index 0000000000..2e9a3ffd72 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-2019.hpp @@ -0,0 +1,10 @@ +// bindgen-flags: --disable-nested-struct-naming + +struct A { + static A make(); + int a; +}; +struct B { + static B make(); + int b; +}; diff --git a/bindgen-tests/tests/headers/issue-2239-template-dependent-bit-width.hpp b/bindgen-tests/tests/headers/issue-2239-template-dependent-bit-width.hpp new file mode 100644 index 0000000000..4e6feb3f1e --- /dev/null +++ b/bindgen-tests/tests/headers/issue-2239-template-dependent-bit-width.hpp @@ -0,0 +1,10 @@ +template class b { + typedef a td; + using ta = a; + struct foo { + a foo : sizeof(a); + a : sizeof(a); + td : sizeof(td); + ta : sizeof(ta); + }; +}; diff --git a/bindgen-tests/tests/headers/issue-2556.h b/bindgen-tests/tests/headers/issue-2556.h new file mode 100644 index 0000000000..bbb1b874ec --- /dev/null +++ b/bindgen-tests/tests/headers/issue-2556.h @@ -0,0 +1,4 @@ +// bindgen-flags: --enable-cxx-namespaces -- -x c++ -Itests/headers -include tests/headers/issue-2556/nsStyleStruct.h -include tests/headers/issue-2556/LayoutConstants.h + +#include "issue-2556/nsSize.h" +#include "issue-2556/nsStyleStruct.h" diff --git a/bindgen-tests/tests/headers/issue-2556/LayoutConstants.h b/bindgen-tests/tests/headers/issue-2556/LayoutConstants.h new file mode 100644 index 0000000000..2ed1c864b2 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-2556/LayoutConstants.h @@ -0,0 +1,7 @@ +#include "nsSize.h" + +namespace foo { + +static constexpr nsSize kFallbackIntrinsicSize(0, 0); + +} diff --git a/bindgen-tests/tests/headers/issue-2556/nsSize.h b/bindgen-tests/tests/headers/issue-2556/nsSize.h new file mode 100644 index 0000000000..8fe8b95023 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-2556/nsSize.h @@ -0,0 +1,6 @@ +#pragma once + +struct nsSize { + int width, height; + constexpr nsSize(int aWidth, int aHeight) : width(aWidth), height(aHeight) {} +}; diff --git a/bindgen-tests/tests/headers/issue-2556/nsStyleStruct.h b/bindgen-tests/tests/headers/issue-2556/nsStyleStruct.h new file mode 100644 index 0000000000..4c6eedfb9a --- /dev/null +++ b/bindgen-tests/tests/headers/issue-2556/nsStyleStruct.h @@ -0,0 +1,3 @@ +#pragma once + +#include "nsSize.h" diff --git a/bindgen-tests/tests/headers/issue-2566-cstr.h b/bindgen-tests/tests/headers/issue-2566-cstr.h new file mode 100644 index 0000000000..674b894024 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-2566-cstr.h @@ -0,0 +1,4 @@ +// bindgen-flags: --generate-cstr + +/// We should _not_ generate a cstr for this because cstr shouldn't have interior nulls. +#define FOO "a\0b" diff --git a/bindgen-tests/tests/headers/issue-2566.h b/bindgen-tests/tests/headers/issue-2566.h new file mode 100644 index 0000000000..6e15ec1979 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-2566.h @@ -0,0 +1 @@ +#define FOO "a\0b" diff --git a/bindgen-tests/tests/headers/issue-2618.h b/bindgen-tests/tests/headers/issue-2618.h new file mode 100644 index 0000000000..841ff61d77 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-2618.h @@ -0,0 +1,18 @@ +// bindgen-flags: --allowlist-var "val[0-9]+" + +typedef __UINT32_TYPE__ uint32_t; +typedef __UINT64_TYPE__ uint64_t; + +static const uint32_t val1 = 0x7fffffff; +static const uint32_t val2 = 0x80000000; +static const uint32_t val3 = 0xffffffff; +static const uint64_t val4 = 0x7fffffffffffffff; +static const uint64_t val5 = 0x8000000000000000; +static const uint64_t val6 = 0xffffffffffffffff; + +static const uint32_t val7 = (0x7fffffff); +static const uint32_t val8 = (0x80000000); +static const uint32_t val9 = (0xffffffff); +static const uint64_t val10 = (0x7fffffffffffffff); +static const uint64_t val11 = (0x8000000000000000); +static const uint64_t val12 = (0xffffffffffffffff); diff --git a/bindgen-tests/tests/headers/issue-2695.h b/bindgen-tests/tests/headers/issue-2695.h new file mode 100644 index 0000000000..4fbcc39bf8 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-2695.h @@ -0,0 +1,10 @@ +// bindgen-flags: --explicit-padding + +#pragma pack(2) + +struct Test { + unsigned long x; + char a; + char b; + char c; +}; diff --git a/bindgen-tests/tests/headers/issue-2966.h b/bindgen-tests/tests/headers/issue-2966.h new file mode 100644 index 0000000000..3f00dec65d --- /dev/null +++ b/bindgen-tests/tests/headers/issue-2966.h @@ -0,0 +1,6 @@ +// bindgen-flags: --default-alias-style=new_type +// bindgen-parse-callbacks: type-visibility + +typedef const char * pub_var1; +typedef const char * pubcrate_var2; +typedef const char * private_var3; diff --git a/bindgen-tests/tests/headers/issue-3027.hpp b/bindgen-tests/tests/headers/issue-3027.hpp new file mode 100644 index 0000000000..d9b87ee6e2 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-3027.hpp @@ -0,0 +1,6 @@ +// bindgen-flags: --enable-cxx-namespaces + +namespace regression { + template class A { char c[N]; }; + class C { A<3> a; }; +} diff --git a/bindgen-tests/tests/headers/issue-358.hpp b/bindgen-tests/tests/headers/issue-358.hpp new file mode 100644 index 0000000000..b14521b73b --- /dev/null +++ b/bindgen-tests/tests/headers/issue-358.hpp @@ -0,0 +1,8 @@ +// bindgen-flags: -- -std=c++11 +namespace JS { +template class PersistentRooted; +} +template class a { a *b; }; +namespace JS { +template class PersistentRooted : a> {}; +} diff --git a/bindgen-tests/tests/headers/issue-372.hpp b/bindgen-tests/tests/headers/issue-372.hpp new file mode 100644 index 0000000000..7127be2ccb --- /dev/null +++ b/bindgen-tests/tests/headers/issue-372.hpp @@ -0,0 +1,16 @@ +// bindgen-flags: --enable-cxx-namespaces --rustified-enum ".*" +template class c { a e[b]; }; +class d; +template class C { c h; }; +class i { + i *j; + i *k; + bool l; +}; +class d { + i m; +}; +enum n { o, p, q, r, s, t, b, ae, e, ag, ah, ai }; +class F { + C w; +}; diff --git a/bindgen-tests/tests/headers/issue-410.hpp b/bindgen-tests/tests/headers/issue-410.hpp new file mode 100644 index 0000000000..d4f3de3d1c --- /dev/null +++ b/bindgen-tests/tests/headers/issue-410.hpp @@ -0,0 +1,12 @@ +// bindgen-flags: --enable-cxx-namespaces --allowlist-type JS::Value --rustified-enum ".*" + +namespace JS { +class Value; +} +typedef enum {} JSWhyMagic; +namespace JS { +class Value { +public: + void a(JSWhyMagic); +}; +} diff --git a/bindgen-tests/tests/headers/issue-446.hpp b/bindgen-tests/tests/headers/issue-446.hpp new file mode 100644 index 0000000000..2e09c2745b --- /dev/null +++ b/bindgen-tests/tests/headers/issue-446.hpp @@ -0,0 +1,11 @@ +// bindgen-flags: -- -std=c++14 + +template +class List { + List *next; +}; + +template +class PersistentRooted { + List> root_list; +}; diff --git a/bindgen-tests/tests/headers/issue-447.hpp b/bindgen-tests/tests/headers/issue-447.hpp new file mode 100644 index 0000000000..43765fa9ee --- /dev/null +++ b/bindgen-tests/tests/headers/issue-447.hpp @@ -0,0 +1,27 @@ +// bindgen-flags: --enable-cxx-namespaces --allowlist-type JSAutoCompartment -- -std=c++11 + +namespace mozilla { + template class a {}; + namespace detail { + class GuardObjectNotifier {}; + struct b; + } + class c { + typedef detail::b d; + }; +} +namespace js { + class D { + mozilla::a e; + }; +} +struct f { + js::D g; +}; +namespace js { + struct ContextFriendFields : f {}; +} +class JSAutoCompartment { +public: + JSAutoCompartment(mozilla::detail::GuardObjectNotifier); +}; diff --git a/bindgen-tests/tests/headers/issue-493.hpp b/bindgen-tests/tests/headers/issue-493.hpp new file mode 100644 index 0000000000..8b122ceb50 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-493.hpp @@ -0,0 +1,48 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*" +template +class basic_string +{ +public: + typedef unsigned long long size_type; + typedef char value_type; + typedef value_type * pointer; + + struct __long + { + size_type __cap_; + size_type __size_; + pointer __data_; + }; + + enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ? + (sizeof(__long) - 1)/sizeof(value_type) : 2}; + + struct __short + { + union + { + unsigned char __size_; + value_type __lx; + }; + value_type __data_[__min_cap]; + }; + + union __ulx{__long __lx; __short __lxx;}; + + enum {__n_words = sizeof(__ulx) / sizeof(size_type)}; + + struct __raw + { + size_type __words[__n_words]; + }; + + struct __rep + { + union + { + __long __l; + __short __s; + __raw __r; + }; + }; +}; diff --git a/bindgen-tests/tests/headers/issue-511.h b/bindgen-tests/tests/headers/issue-511.h new file mode 100644 index 0000000000..da3643121e --- /dev/null +++ b/bindgen-tests/tests/headers/issue-511.h @@ -0,0 +1,4 @@ +char * a; +const char * b; +char * const c; +const char * const d; \ No newline at end of file diff --git a/bindgen-tests/tests/headers/issue-537-repr-packed-n.h b/bindgen-tests/tests/headers/issue-537-repr-packed-n.h new file mode 100644 index 0000000000..40be004c85 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-537-repr-packed-n.h @@ -0,0 +1,34 @@ +// bindgen-flags: --raw-line '#![cfg(feature = "nightly")]' + +/// This should not be opaque; we can see the attributes and can pack the +/// struct. +struct AlignedToOne { + int i; +} __attribute__ ((packed,aligned(1))); + +/// This should be packed because Rust 1.33 has `#[repr(packed(N))]`. +struct AlignedToTwo { + int i; +} __attribute__ ((packed,aligned(2))); + +#pragma pack(1) + +/// This should not be opaque because although `libclang` doesn't give us the +/// `#pragma pack(1)`, we can detect that alignment is 1 and add +/// `#[repr(packed)]` to the struct ourselves. +struct PackedToOne { + int x; + int y; +}; + +#pragma pack() + +#pragma pack(2) + +/// This should be packed because Rust 1.33 has `#[repr(packed(N))]`. +struct PackedToTwo { + int x; + int y; +}; + +#pragma pack() diff --git a/bindgen-tests/tests/headers/issue-537.h b/bindgen-tests/tests/headers/issue-537.h new file mode 100644 index 0000000000..a773199f09 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-537.h @@ -0,0 +1,35 @@ +/// This should not be opaque; we can see the attributes and can pack the +/// struct. +struct AlignedToOne { + int i; +} __attribute__ ((packed,aligned(1))); + +/// This should be opaque because although we can see the attributes, Rust before +/// 1.33 doesn't have `#[repr(packed(N))]`. +struct AlignedToTwo { + int i; +} __attribute__ ((packed,aligned(2))); + +#pragma pack(1) + +/// This should not be opaque because although `libclang` doesn't give us the +/// `#pragma pack(1)`, we can detect that alignment is 1 and add +/// `#[repr(packed)]` to the struct ourselves. +struct PackedToOne { + int x; + int y; +}; + +#pragma pack() + +#pragma pack(2) + +/// In this case, even if we can detect the weird alignment triggered by +/// `#pragma pack(2)`, we can't do anything about it because Rust before 1.33 +/// doesn't have `#[repr(packed(N))]`. Therefore, we must make it opaque. +struct PackedToTwo { + int x; + int y; +}; + +#pragma pack() diff --git a/bindgen-tests/tests/headers/issue-544-stylo-creduce-2.hpp b/bindgen-tests/tests/headers/issue-544-stylo-creduce-2.hpp new file mode 100644 index 0000000000..b41b422d1e --- /dev/null +++ b/bindgen-tests/tests/headers/issue-544-stylo-creduce-2.hpp @@ -0,0 +1,15 @@ +// bindgen-flags: -- -std=c++14 + +template +struct Foo { + template using FirstAlias = typename T::Associated; + template using SecondAlias = Foo>; + +#if 0 + // FIXME: This regressed sometime between libclang 9 and 16, though it + // never quite worked properly so... + SecondAlias member; +#else + SecondAlias* member; +#endif +}; diff --git a/bindgen-tests/tests/headers/issue-544-stylo-creduce.hpp b/bindgen-tests/tests/headers/issue-544-stylo-creduce.hpp new file mode 100644 index 0000000000..ba9f82575c --- /dev/null +++ b/bindgen-tests/tests/headers/issue-544-stylo-creduce.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: -- -std=c++14 + +template class a; +template class a { a(const a &); }; +template a::a(const a &) {} diff --git a/bindgen-tests/tests/headers/issue-569-non-type-template-params-causing-layout-test-failures.hpp b/bindgen-tests/tests/headers/issue-569-non-type-template-params-causing-layout-test-failures.hpp new file mode 100644 index 0000000000..297d111291 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-569-non-type-template-params-causing-layout-test-failures.hpp @@ -0,0 +1,27 @@ +// bindgen-flags: --rustified-enum ".*" -- -std=c++14 + +// Generated by C-Reduce, cleaned up and given names for readability. + +template +struct HasNonTypeTemplateParam { + // But doesn't use the non-type template param nor its type param... +}; + +enum { + ENUM_VARIANT_1, + ENUM_VARIANT_2 +}; + +namespace JS { + +template +using Alias = HasNonTypeTemplateParam; + +template +class Base { + Alias f; +}; + +class AutoIdVector : Base {}; + +} diff --git a/bindgen-tests/tests/headers/issue-573-layout-test-failures.hpp b/bindgen-tests/tests/headers/issue-573-layout-test-failures.hpp new file mode 100644 index 0000000000..ac8cbd4834 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-573-layout-test-failures.hpp @@ -0,0 +1,12 @@ +template +struct UnusedIntTemplateParam {}; + +template +class Outer { + static const long SIZE = 1; + UnusedIntTemplateParam i; +}; + +class AutoIdVector { + Outer ar; +}; diff --git a/bindgen-tests/tests/headers/issue-574-assertion-failure-in-codegen.hpp b/bindgen-tests/tests/headers/issue-574-assertion-failure-in-codegen.hpp new file mode 100644 index 0000000000..b563b4efca --- /dev/null +++ b/bindgen-tests/tests/headers/issue-574-assertion-failure-in-codegen.hpp @@ -0,0 +1,6 @@ +// bindgen-flags: -- -std=c++14 + +template class a {}; +class { + a ar; +} AutoIdVector; diff --git a/bindgen-tests/tests/headers/issue-584-stylo-template-analysis-panic.hpp b/bindgen-tests/tests/headers/issue-584-stylo-template-analysis-panic.hpp new file mode 100644 index 0000000000..5f11ea3c9c --- /dev/null +++ b/bindgen-tests/tests/headers/issue-584-stylo-template-analysis-panic.hpp @@ -0,0 +1,13 @@ +// bindgen-flags: --blocklist-type RefPtr --allowlist-function 'Servo_.*' --raw-line 'pub type RefPtr = T;' -- -std=c++14 +template class RefPtr; +class b; +class A { + typedef b a; +}; +template class e { RefPtr d; }; +template class f {}; +class g { + f> h; +}; +class b : g {}; +A Servo_Element_GetSnapshot(); diff --git a/bindgen-tests/tests/headers/issue-638-stylo-cannot-find-T-in-this-scope.hpp b/bindgen-tests/tests/headers/issue-638-stylo-cannot-find-T-in-this-scope.hpp new file mode 100644 index 0000000000..13b656e156 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-638-stylo-cannot-find-T-in-this-scope.hpp @@ -0,0 +1,12 @@ +// bindgen-flags: -- -std=c++14 + +template +class RefPtr { + T use_of_t; +}; + +template +class UsesRefPtrWithAliasedTypeParam { + using V = U; + RefPtr member; +}; diff --git a/bindgen-tests/tests/headers/issue-639-typedef-anon-field.hpp b/bindgen-tests/tests/headers/issue-639-typedef-anon-field.hpp new file mode 100644 index 0000000000..efd6c4f40a --- /dev/null +++ b/bindgen-tests/tests/headers/issue-639-typedef-anon-field.hpp @@ -0,0 +1,15 @@ +class Foo { + public: + typedef struct { + int abc; + } Bar; + + Bar bar; +}; + +class Baz { + public: + typedef struct { + int abc; + } Bar; +}; diff --git a/bindgen-tests/tests/headers/issue-643-inner-struct.h b/bindgen-tests/tests/headers/issue-643-inner-struct.h new file mode 100644 index 0000000000..25c525b357 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-643-inner-struct.h @@ -0,0 +1,13 @@ +struct rte_ring { + struct rte_memzone *memzone; + + struct prod { + unsigned watermark; + } prod; + + struct cons { + unsigned sc_dequeue; + } cons; + + void *ring[]; +}; diff --git a/bindgen-tests/tests/headers/issue-645-cannot-find-type-T-in-this-scope.hpp b/bindgen-tests/tests/headers/issue-645-cannot-find-type-T-in-this-scope.hpp new file mode 100644 index 0000000000..8e07a8a0fd --- /dev/null +++ b/bindgen-tests/tests/headers/issue-645-cannot-find-type-T-in-this-scope.hpp @@ -0,0 +1,9 @@ +// bindgen-flags: --blocklist-type RefPtr --raw-line "#[derive(Clone, Copy, Debug)] pub struct RefPtr(T);" --allowlist-type "HasRefPtr" -- -std=c++14 + +template class RefPtr {}; + +template +class HasRefPtr { + typedef T TypedefOfT; + RefPtr refptr_member; +}; diff --git a/bindgen-tests/tests/headers/issue-648-derive-debug-with-padding.h b/bindgen-tests/tests/headers/issue-648-derive-debug-with-padding.h new file mode 100644 index 0000000000..d54fe374ce --- /dev/null +++ b/bindgen-tests/tests/headers/issue-648-derive-debug-with-padding.h @@ -0,0 +1,21 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --impl-partialeq +/** + * We emit a `[u8; 63usize]` padding field for this struct, which cannot derive + * Debug/Hash because 63 is over the hard coded limit. + */ +struct NoDebug { + char c; + // padding of 63 bytes +} __attribute__((__aligned__(64))); + +/** + * This should derive Debug/Hash/PartialEq/Eq because the padding size is less than the max derive + * Debug/Hash/PartialEq/Eq impl for arrays. However, we conservatively don't derive Debug/Hash because + * we determine Debug derive-ability before we compute padding, which happens at + * codegen. + */ +struct ShouldDeriveDebugButDoesNot { + char c[32]; + char d; + // padding of 31 bytes +} __attribute__((__aligned__(64))); diff --git a/bindgen-tests/tests/headers/issue-654-struct-fn-collision.h b/bindgen-tests/tests/headers/issue-654-struct-fn-collision.h new file mode 100644 index 0000000000..f52a1b200c --- /dev/null +++ b/bindgen-tests/tests/headers/issue-654-struct-fn-collision.h @@ -0,0 +1,2 @@ +struct foo; +int foo(void); diff --git a/bindgen-tests/tests/headers/issue-662-cannot-find-T-in-this-scope.hpp b/bindgen-tests/tests/headers/issue-662-cannot-find-T-in-this-scope.hpp new file mode 100644 index 0000000000..6b3f928b0b --- /dev/null +++ b/bindgen-tests/tests/headers/issue-662-cannot-find-T-in-this-scope.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: -- --std=c++14 + +template class RefPtr { T a; }; +template class nsMainThreadPtrHolder { T a; }; +template class nsMainThreadPtrHandle { + RefPtr> mPtr; +}; diff --git a/bindgen-tests/tests/headers/issue-662-part-2.hpp b/bindgen-tests/tests/headers/issue-662-part-2.hpp new file mode 100644 index 0000000000..1330c34280 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-662-part-2.hpp @@ -0,0 +1,11 @@ +// bindgen-flags: --blocklist-type RefPtr --raw-line '#[derive(Clone, Copy, Debug)] pub struct RefPtr(T);' -- --std=c++14 + +// This is pretty much the same as the other issue 662 test case, but this time +// we blocklist RefPtr to exercise the instantiation-of-a-blocklisted-template +// path in the template analysis. + +template class RefPtr {}; +template class nsMainThreadPtrHolder { T a; }; +template class nsMainThreadPtrHandle { + RefPtr> mPtr; +}; diff --git a/bindgen-tests/tests/headers/issue-674-1.hpp b/bindgen-tests/tests/headers/issue-674-1.hpp new file mode 100644 index 0000000000..7fc781c1da --- /dev/null +++ b/bindgen-tests/tests/headers/issue-674-1.hpp @@ -0,0 +1,8 @@ +// bindgen-flags: --enable-cxx-namespaces --allowlist-type CapturingContentInfo --opaque-type 'mozilla::Maybe' -- -std=c++14 + +namespace mozilla { +template class Maybe { using ValueType = T; }; +} +struct CapturingContentInfo { + mozilla::Maybe a; +}; diff --git a/bindgen-tests/tests/headers/issue-674-2.hpp b/bindgen-tests/tests/headers/issue-674-2.hpp new file mode 100644 index 0000000000..86d2b6488d --- /dev/null +++ b/bindgen-tests/tests/headers/issue-674-2.hpp @@ -0,0 +1,15 @@ +// bindgen-flags: --enable-cxx-namespaces --allowlist-type StaticRefPtr --opaque-type 'JS::Rooted' -- -std=c++14 + +namespace JS { +template class Rooted { using ElementType = T; }; +} +class c { + JS::Rooted b; +}; +class B { + c a; +}; +template class StaticRefPtr {}; +struct { + StaticRefPtr d; +} e; diff --git a/bindgen-tests/tests/headers/issue-674-3.hpp b/bindgen-tests/tests/headers/issue-674-3.hpp new file mode 100644 index 0000000000..20aa463c9e --- /dev/null +++ b/bindgen-tests/tests/headers/issue-674-3.hpp @@ -0,0 +1,11 @@ +// bindgen-flags: --enable-cxx-namespaces --allowlist-type nsCSSValue --opaque-type 'nsRefPtrHashtable' -- -std=c++14 + +template class nsRefPtrHashtable { + typedef PtrType *UserDataType; +}; +struct a { + nsRefPtrHashtable b; +}; +class nsCSSValue { + a c; +}; diff --git a/bindgen-tests/tests/headers/issue-677-nested-ns-specifier.hpp b/bindgen-tests/tests/headers/issue-677-nested-ns-specifier.hpp new file mode 100644 index 0000000000..ef2cea82dc --- /dev/null +++ b/bindgen-tests/tests/headers/issue-677-nested-ns-specifier.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: --enable-cxx-namespaces -- -std=c++14 + +namespace foo::bar { + typedef int bar; +} diff --git a/bindgen-tests/tests/headers/issue-691-template-parameter-virtual.hpp b/bindgen-tests/tests/headers/issue-691-template-parameter-virtual.hpp new file mode 100644 index 0000000000..f80e058dd7 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-691-template-parameter-virtual.hpp @@ -0,0 +1,12 @@ +class VirtualMethods { + virtual void foo(); +}; + +template +class Set { + int bar; +}; + +class ServoElementSnapshotTable + : public Set +{}; diff --git a/bindgen-tests/tests/headers/issue-710-must-use-type.h b/bindgen-tests/tests/headers/issue-710-must-use-type.h new file mode 100644 index 0000000000..276f636d70 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-710-must-use-type.h @@ -0,0 +1,8 @@ +// bindgen-flags: --must-use-type A + +struct A; + +/**
*/ +struct B; + +struct C; diff --git a/bindgen-tests/tests/headers/issue-739-pointer-wide-bitfield.h b/bindgen-tests/tests/headers/issue-739-pointer-wide-bitfield.h new file mode 100644 index 0000000000..eeb7ae9c2d --- /dev/null +++ b/bindgen-tests/tests/headers/issue-739-pointer-wide-bitfield.h @@ -0,0 +1,9 @@ +// bindgen-flags: --raw-line '#![cfg(not(target_os="windows"))]' +#define POINTER_WIDTH (sizeof(void*) * 8) + +struct Foo { + unsigned long m_bitfield: POINTER_WIDTH; + unsigned long m_bar: POINTER_WIDTH; + unsigned long foo: 1; + unsigned long bar: POINTER_WIDTH; +}; diff --git a/bindgen-tests/tests/headers/issue-743.h b/bindgen-tests/tests/headers/issue-743.h new file mode 100644 index 0000000000..1f8e0ccd78 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-743.h @@ -0,0 +1,6 @@ + +struct S { + void *p; + _Bool b; + unsigned u : 16; +}; \ No newline at end of file diff --git a/bindgen-tests/tests/headers/issue-753.h b/bindgen-tests/tests/headers/issue-753.h new file mode 100644 index 0000000000..3a6c82528a --- /dev/null +++ b/bindgen-tests/tests/headers/issue-753.h @@ -0,0 +1,12 @@ +// bindgen-flags: --clang-macro-fallback + +#ifndef ISSUE_753_H +#define ISSUE_753_H + +#define UINT32_C(c) c ## U + +#define CONST UINT32_C(5) +#define OTHER_CONST UINT32_C(6) +#define LARGE_CONST UINT32_C(6 << 8) + +#endif diff --git a/bindgen-tests/tests/headers/issue-769-bad-instantiation-test.hpp b/bindgen-tests/tests/headers/issue-769-bad-instantiation-test.hpp new file mode 100644 index 0000000000..13c6dd1ce6 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-769-bad-instantiation-test.hpp @@ -0,0 +1,11 @@ +// bindgen-flags: --enable-cxx-namespaces --allowlist-type Rooted + +template +class Rooted { + T member; +}; + +class AutoValueVector : Rooted { + using Alias = int; + using RootedAlias = Rooted; +}; diff --git a/bindgen-tests/tests/headers/issue-801-opaque-sloppiness.hpp b/bindgen-tests/tests/headers/issue-801-opaque-sloppiness.hpp new file mode 100644 index 0000000000..6b707f4ede --- /dev/null +++ b/bindgen-tests/tests/headers/issue-801-opaque-sloppiness.hpp @@ -0,0 +1,11 @@ +// bindgen-flags: --opaque-type "B" --allowlist-type "C" --with-derive-hash --with-derive-partialeq --with-derive-eq + +class A; + +class B { + static A a; +}; + +class C { + B b; +}; diff --git a/bindgen-tests/tests/headers/issue-807-opaque-types-methods-being-generated.hpp b/bindgen-tests/tests/headers/issue-807-opaque-types-methods-being-generated.hpp new file mode 100644 index 0000000000..de98b32a15 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-807-opaque-types-methods-being-generated.hpp @@ -0,0 +1,36 @@ +// bindgen-flags: --allowlist-type Allowlisted --opaque-type Opaque --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++11 + +// These types are not explicitly allowlisted, but are reachable through the +// opaque type. +class Pupper {}; +class Doggo {}; +class SuchWow {}; + +// These types are not allowlisted, and would be reachable through `Opaque` if +// it were not marked opaque, but since it is, there should be no bindings +// generated for them. +class NoBindingsShouldBeGeneratedForMe1 {}; +class NoBindingsShouldBeGeneratedForMe2 {}; + +// Exercise the different kinds of outgoing edges from an opaque type. +class Opaque + // Base member edge. + : public NoBindingsShouldBeGeneratedForMe1 { + +protected: + // Field edge. + NoBindingsShouldBeGeneratedForMe2 field; + + // Constructor edge. + Opaque(Pupper pup); + + // Inner static variable edge. + static Doggo MAJESTIC_AF; + + // Method edge. + SuchWow eleven_out_of_ten(); +}; + +class Allowlisted { + Opaque some_member; +}; diff --git a/bindgen-tests/tests/headers/issue-816.h b/bindgen-tests/tests/headers/issue-816.h new file mode 100644 index 0000000000..5f16a1786b --- /dev/null +++ b/bindgen-tests/tests/headers/issue-816.h @@ -0,0 +1,49 @@ +typedef struct { + unsigned int bit_1 : 1; + unsigned int bit_2 : 1; + unsigned int bit_3 : 1; + unsigned int bit_4 : 1; + unsigned int bit_5 : 1; + unsigned int bit_6 : 1; + unsigned int bit_7 : 1; + unsigned int bit_8 : 1; + unsigned int bit_9 : 1; + unsigned int bit_10 : 1; + unsigned int bit_11 : 1; + unsigned int bit_12 : 1; + unsigned int bit_13 : 1; + unsigned int bit_14 : 1; + unsigned int bit_15 : 1; + unsigned int bit_16 : 1; + unsigned int bit_17 : 1; + unsigned int bit_18 : 1; + unsigned int bit_19 : 1; + unsigned int bit_20 : 1; + unsigned int bit_21 : 1; + unsigned int bit_22 : 1; + unsigned int bit_23 : 1; + unsigned int bit_24 : 1; + unsigned int bit_25 : 1; + unsigned int bit_26 : 1; + unsigned int bit_27 : 1; + unsigned int bit_28 : 1; + unsigned int bit_29 : 1; + unsigned int bit_30 : 1; + unsigned int bit_31 : 1; + unsigned int bit_32 : 1; + unsigned int bit_33 : 1; + unsigned int bit_34 : 1; + unsigned int bit_35 : 1; + unsigned int bit_36 : 1; + unsigned int bit_37 : 1; + unsigned int bit_38 : 1; + unsigned int bit_39 : 1; + unsigned int bit_40 : 1; + unsigned int bit_41 : 1; + unsigned int : 7; + unsigned int : 16; + unsigned int : 16; + unsigned int : 16; + unsigned int : 16; + unsigned int : 16; +} capabilities; diff --git a/bindgen-tests/tests/headers/issue-820-unused-template-param-in-alias.hpp b/bindgen-tests/tests/headers/issue-820-unused-template-param-in-alias.hpp new file mode 100644 index 0000000000..ca5d8b9653 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-820-unused-template-param-in-alias.hpp @@ -0,0 +1,5 @@ +template +class Foo { + typedef Foo self_type; + E mBar; +}; diff --git a/bindgen-tests/tests/headers/issue-826-generating-methods-when-asked-not-to.hpp b/bindgen-tests/tests/headers/issue-826-generating-methods-when-asked-not-to.hpp new file mode 100644 index 0000000000..f6b2ed30ad --- /dev/null +++ b/bindgen-tests/tests/headers/issue-826-generating-methods-when-asked-not-to.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: --ignore-methods -- --target=i686-pc-win32 + +struct Foo { + void test(); +}; diff --git a/bindgen-tests/tests/headers/issue-833-1.hpp b/bindgen-tests/tests/headers/issue-833-1.hpp new file mode 100644 index 0000000000..d66ee01fa7 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-833-1.hpp @@ -0,0 +1,8 @@ +// bindgen-flags: --generate functions --allowlist-function func --raw-line "#[repr(C)] pub struct nsTArray { pub hdr: *const () }" + +template +class nsTArray { + static T* sFoo; +}; + +extern "C" nsTArray* func(); diff --git a/bindgen-tests/tests/headers/issue-833-2.hpp b/bindgen-tests/tests/headers/issue-833-2.hpp new file mode 100644 index 0000000000..487c56075e --- /dev/null +++ b/bindgen-tests/tests/headers/issue-833-2.hpp @@ -0,0 +1,6 @@ +// bindgen-flags: --raw-line "// If the output of this changes, please ensure issue-833-1.hpp changes too" + +template +class nsTArray { + static T* sFoo; +}; diff --git a/bindgen-tests/tests/headers/issue-833.hpp b/bindgen-tests/tests/headers/issue-833.hpp new file mode 100644 index 0000000000..f8b708bf16 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-833.hpp @@ -0,0 +1,8 @@ +// bindgen-flags: --generate functions --allowlist-function func --raw-line "#[repr(C)] pub struct nsTArray { pub hdr: *const T }" + +template +class nsTArray { + T* mHeader; +}; + +extern "C" nsTArray* func(); diff --git a/bindgen-tests/tests/headers/issue-834.hpp b/bindgen-tests/tests/headers/issue-834.hpp new file mode 100644 index 0000000000..6479701262 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-834.hpp @@ -0,0 +1,6 @@ +// bindgen-flags: --allowlist-type U --generate types + +struct T {}; +struct U { + void test(T a); +}; diff --git a/bindgen-tests/tests/headers/issue-848-replacement-system-include.hpp b/bindgen-tests/tests/headers/issue-848-replacement-system-include.hpp new file mode 100644 index 0000000000..e95c823ff8 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-848-replacement-system-include.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: -- -Itests/headers/issue-848 + +#include "an-include.h" + +extern "C" { + nsTArray* func(); +} diff --git a/bindgen-tests/tests/headers/issue-848/an-include.h b/bindgen-tests/tests/headers/issue-848/an-include.h new file mode 100644 index 0000000000..0421d19f4e --- /dev/null +++ b/bindgen-tests/tests/headers/issue-848/an-include.h @@ -0,0 +1,17 @@ +template +class nsTArray { + void* mBuffer; +}; + +/** + * This is intended to replace another type, but won't if we treat this include + * as a system include, because clang doesn't parse comments there. + * + * See #848. + * + *
+ */ +template +class nsTArray_Simple { + T* m; +}; diff --git a/bindgen-tests/tests/headers/issue-888-enum-var-decl-jump.hpp b/bindgen-tests/tests/headers/issue-888-enum-var-decl-jump.hpp new file mode 100644 index 0000000000..fa4ba56ba4 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-888-enum-var-decl-jump.hpp @@ -0,0 +1,11 @@ +// bindgen-flags: --enable-cxx-namespaces --rustified-enum ".*" + +namespace Halide { +struct Type; +} +typedef enum {} a; +namespace Halide { +struct Type { + static a b; +}; +} diff --git a/bindgen-tests/tests/headers/issue-944-derive-copy-and-blocklisting.hpp b/bindgen-tests/tests/headers/issue-944-derive-copy-and-blocklisting.hpp new file mode 100644 index 0000000000..5e94dfabd4 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-944-derive-copy-and-blocklisting.hpp @@ -0,0 +1,10 @@ +// bindgen-flags: --blocklist-type BlocklistMe --raw-line 'pub struct BlocklistMe(u8);' + +struct BlocklistMe {}; + +/** + * Because this type contains a blocklisted type, it should not derive Copy. + */ +struct ShouldNotBeCopy { + BlocklistMe a; +}; diff --git a/bindgen-tests/tests/headers/issue-946.h b/bindgen-tests/tests/headers/issue-946.h new file mode 100644 index 0000000000..5d145e09a8 --- /dev/null +++ b/bindgen-tests/tests/headers/issue-946.h @@ -0,0 +1,5 @@ +struct foo { }; + +typedef struct foo bar; + +typedef bar foo; diff --git a/bindgen-tests/tests/headers/issue_311.hpp b/bindgen-tests/tests/headers/issue_311.hpp new file mode 100644 index 0000000000..a8d7fd997d --- /dev/null +++ b/bindgen-tests/tests/headers/issue_311.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: --enable-cxx-namespaces + +struct jsval_layout { + struct {}; +}; diff --git a/bindgen-tests/tests/headers/issue_315.hpp b/bindgen-tests/tests/headers/issue_315.hpp new file mode 100644 index 0000000000..e58cb5e335 --- /dev/null +++ b/bindgen-tests/tests/headers/issue_315.hpp @@ -0,0 +1,2 @@ +///
+template using b = a; diff --git a/tests/headers/jsval_layout_opaque.hpp b/bindgen-tests/tests/headers/jsval_layout_opaque.hpp similarity index 99% rename from tests/headers/jsval_layout_opaque.hpp rename to bindgen-tests/tests/headers/jsval_layout_opaque.hpp index 85c5be63c4..ef13b85b25 100644 --- a/tests/headers/jsval_layout_opaque.hpp +++ b/bindgen-tests/tests/headers/jsval_layout_opaque.hpp @@ -1,4 +1,5 @@ -// bindgen-flags: --no-unstable-rust -- -std=c++11 +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*" +// bindgen-flags: -- -std=c++11 /** * These typedefs are hacky, but keep our tests consistent across 64-bit diff --git a/tests/headers/keywords.h b/bindgen-tests/tests/headers/keywords.h similarity index 87% rename from tests/headers/keywords.h rename to bindgen-tests/tests/headers/keywords.h index 8699ce5f22..49924193c7 100644 --- a/tests/headers/keywords.h +++ b/bindgen-tests/tests/headers/keywords.h @@ -10,11 +10,18 @@ int f32; int f64; int usize; int isize; +int bool; +int str; +int dyn; + int as; +int async; +int await; int box; int crate; int false; int fn; +int gen; int impl; int in; int let; @@ -30,6 +37,7 @@ int Self; int super; int trait; int true; +int try; int type; int unsafe; int use; diff --git a/bindgen-tests/tests/headers/layout.h b/bindgen-tests/tests/headers/layout.h new file mode 100644 index 0000000000..06b7165ab9 --- /dev/null +++ b/bindgen-tests/tests/headers/layout.h @@ -0,0 +1,11 @@ +// FIXME: https://github.com/rust-lang/rust-bindgen/issues/1498 + + +#if 0 +struct header +{ + char proto; + unsigned int size __attribute__ ((packed)); + unsigned char data[] __attribute__ ((aligned(8))); +} __attribute__ ((aligned, packed)); +#endif diff --git a/bindgen-tests/tests/headers/layout_align.h b/bindgen-tests/tests/headers/layout_align.h new file mode 100644 index 0000000000..0201877e79 --- /dev/null +++ b/bindgen-tests/tests/headers/layout_align.h @@ -0,0 +1,20 @@ +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +typedef unsigned long long uint64_t; + +struct rte_kni_fifo { + volatile unsigned write; /**< Next position to be written*/ + volatile unsigned read; /**< Next position to be read */ + unsigned len; /**< Circular buffer length */ + unsigned elem_size; /**< Pointer size - for 32/64 bit OS */ + void *volatile buffer[]; /**< The buffer contains mbuf pointers */ +}; + +__extension__ +struct rte_eth_link { + uint32_t link_speed; /**< ETH_SPEED_NUM_ */ + uint16_t link_duplex : 1; /**< ETH_LINK_[HALF/FULL]_DUPLEX */ + uint16_t link_autoneg : 1; /**< ETH_LINK_SPEED_[AUTONEG/FIXED] */ + uint16_t link_status : 1; /**< ETH_LINK_[DOWN/UP] */ +} __attribute__((aligned(8))); /**< aligned for atomic64 read/write */ \ No newline at end of file diff --git a/bindgen-tests/tests/headers/layout_arp.h b/bindgen-tests/tests/headers/layout_arp.h new file mode 100644 index 0000000000..8682cbe0ee --- /dev/null +++ b/bindgen-tests/tests/headers/layout_arp.h @@ -0,0 +1,52 @@ +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +typedef unsigned long long uint64_t; + +#define ETHER_ADDR_LEN 6 /**< Length of Ethernet address. */ + +/** + * Ethernet address: + * A universally administered address is uniquely assigned to a device by its + * manufacturer. The first three octets (in transmission order) contain the + * Organizationally Unique Identifier (OUI). The following three (MAC-48 and + * EUI-48) octets are assigned by that organization with the only constraint + * of uniqueness. + * A locally administered address is assigned to a device by a network + * administrator and does not contain OUIs. + * See http://standards.ieee.org/regauth/groupmac/tutorial.html + */ +struct ether_addr { + uint8_t addr_bytes[ETHER_ADDR_LEN]; /**< Addr bytes in tx order */ +} __attribute__((__packed__)); + +/** + * ARP header IPv4 payload. + */ +struct arp_ipv4 { + struct ether_addr arp_sha; /**< sender hardware address */ + uint32_t arp_sip; /**< sender IP address */ + struct ether_addr arp_tha; /**< target hardware address */ + uint32_t arp_tip; /**< target IP address */ +} __attribute__((__packed__)); + +/** + * ARP header. + */ +struct arp_hdr { + uint16_t arp_hrd; /* format of hardware address */ +#define ARP_HRD_ETHER 1 /* ARP Ethernet address format */ + + uint16_t arp_pro; /* format of protocol address */ + uint8_t arp_hln; /* length of hardware address */ + uint8_t arp_pln; /* length of protocol address */ + uint16_t arp_op; /* ARP opcode (command) */ +#define ARP_OP_REQUEST 1 /* request to resolve address */ +#define ARP_OP_REPLY 2 /* response to previous request */ +#define ARP_OP_REVREQUEST 3 /* request proto addr given hardware */ +#define ARP_OP_REVREPLY 4 /* response giving protocol address */ +#define ARP_OP_INVREQUEST 8 /* request to identify peer */ +#define ARP_OP_INVREPLY 9 /* response identifying peer */ + + struct arp_ipv4 arp_data; +} __attribute__((__packed__)); \ No newline at end of file diff --git a/bindgen-tests/tests/headers/layout_array.h b/bindgen-tests/tests/headers/layout_array.h new file mode 100644 index 0000000000..239e52b193 --- /dev/null +++ b/bindgen-tests/tests/headers/layout_array.h @@ -0,0 +1,110 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --impl-partialeq +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +typedef unsigned long long uint64_t; + +typedef long long size_t; + +#define RTE_CACHE_LINE_SIZE 64 + +/** + * Force alignment + */ +#define __rte_aligned(a) __attribute__((__aligned__(a))) + +/** + * Force alignment to cache line. + */ +#define __rte_cache_aligned __rte_aligned(RTE_CACHE_LINE_SIZE) + +#define RTE_MEMPOOL_OPS_NAMESIZE 32 /**< Max length of ops struct name. */ + +/** + * Prototype for implementation specific data provisioning function. + * + * The function should provide the implementation specific memory for + * for use by the other mempool ops functions in a given mempool ops struct. + * E.g. the default ops provides an instance of the rte_ring for this purpose. + * it will most likely point to a different type of data structure, and + * will be transparent to the application programmer. + * This function should set mp->pool_data. + */ +typedef int (*rte_mempool_alloc_t)(struct rte_mempool *mp); + +/** + * Free the opaque private data pointed to by mp->pool_data pointer. + */ +typedef void (*rte_mempool_free_t)(struct rte_mempool *mp); + +/** + * Enqueue an object into the external pool. + */ +typedef int (*rte_mempool_enqueue_t)(struct rte_mempool *mp, + void * const *obj_table, unsigned int n); + +/** + * Dequeue an object from the external pool. + */ +typedef int (*rte_mempool_dequeue_t)(struct rte_mempool *mp, + void **obj_table, unsigned int n); + +/** + * Return the number of available objects in the external pool. + */ +typedef unsigned (*rte_mempool_get_count)(const struct rte_mempool *mp); +/** Structure defining mempool operations structure */ +struct rte_mempool_ops { + char name[RTE_MEMPOOL_OPS_NAMESIZE]; /**< Name of mempool ops struct. */ + rte_mempool_alloc_t alloc; /**< Allocate private data. */ + rte_mempool_free_t free; /**< Free the external pool. */ + rte_mempool_enqueue_t enqueue; /**< Enqueue an object. */ + rte_mempool_dequeue_t dequeue; /**< Dequeue an object. */ + rte_mempool_get_count get_count; /**< Get qty of available objs. */ +} __rte_cache_aligned; + +#define RTE_MEMPOOL_MAX_OPS_IDX 16 /**< Max registered ops structs */ + +/** + * The rte_spinlock_t type. + */ +typedef struct { + volatile int locked; /**< lock status 0 = unlocked, 1 = locked */ +} rte_spinlock_t; + +/** + * Structure storing the table of registered ops structs, each of which contain + * the function pointers for the mempool ops functions. + * Each process has its own storage for this ops struct array so that + * the mempools can be shared across primary and secondary processes. + * The indices used to access the array are valid across processes, whereas + * any function pointers stored directly in the mempool struct would not be. + * This results in us simply having "ops_index" in the mempool struct. + */ +struct rte_mempool_ops_table { + rte_spinlock_t sl; /**< Spinlock for add/delete. */ + uint32_t num_ops; /**< Number of used ops structs in the table. */ + /** + * Storage for all possible ops structs. + */ + struct rte_mempool_ops ops[RTE_MEMPOOL_MAX_OPS_IDX]; +} __rte_cache_aligned; + + +/* Number of free lists per heap, grouped by size. */ +#define RTE_HEAP_NUM_FREELISTS 13 + +#define LIST_HEAD(name, type) \ +struct name { \ + struct type *lh_first; /* first element */ \ +} + +/** + * Structure to hold malloc heap + */ +struct malloc_heap { + rte_spinlock_t lock; + LIST_HEAD(, malloc_elem) free_head[RTE_HEAP_NUM_FREELISTS]; + unsigned alloc_count; + size_t total_size; +} __rte_cache_aligned; diff --git a/bindgen-tests/tests/headers/layout_array_too_long.h b/bindgen-tests/tests/headers/layout_array_too_long.h new file mode 100644 index 0000000000..d0d34ba038 --- /dev/null +++ b/bindgen-tests/tests/headers/layout_array_too_long.h @@ -0,0 +1,61 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --impl-partialeq --rustified-enum ".*" +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +typedef unsigned long long uint64_t; + +#define RTE_CACHE_LINE_SIZE 64 + +/** + * Force alignment + */ +#define __rte_aligned(a) __attribute__((__aligned__(a))) + +/** + * Force alignment to cache line. + */ +#define __rte_cache_aligned __rte_aligned(RTE_CACHE_LINE_SIZE) + +#define RTE_LIBRTE_IP_FRAG_MAX_FRAG 4 + +enum { + IP_LAST_FRAG_IDX, /**< index of last fragment */ + IP_FIRST_FRAG_IDX, /**< index of first fragment */ + IP_MIN_FRAG_NUM, /**< minimum number of fragments */ + IP_MAX_FRAG_NUM = RTE_LIBRTE_IP_FRAG_MAX_FRAG, + /**< maximum number of fragments per packet */ +}; + +/** @internal fragmented mbuf */ +struct ip_frag { + uint16_t ofs; /**< offset into the packet */ + uint16_t len; /**< length of fragment */ + struct rte_mbuf *mb; /**< fragment mbuf */ +}; + +/** @internal to uniquely indetify fragmented datagram. */ +struct ip_frag_key { + uint64_t src_dst[4]; /**< src address, first 8 bytes used for IPv4 */ + uint32_t id; /**< dst address */ + uint32_t key_len; /**< src/dst key length */ +}; + +#define TAILQ_ENTRY(type) \ +struct { \ + struct type *tqe_next; /* next element */ \ + struct type **tqe_prev; /* address of previous next element */ \ +} + +/** + * @internal Fragmented packet to reassemble. + * First two entries in the frags[] array are for the last and first fragments. + */ +struct ip_frag_pkt { + TAILQ_ENTRY(ip_frag_pkt) lru; /**< LRU list */ + struct ip_frag_key key; /**< fragmentation key */ + uint64_t start; /**< creation timestamp */ + uint32_t total_size; /**< expected reassembled size */ + uint32_t frag_size; /**< size of fragments received */ + uint32_t last_idx; /**< index of next entry to fill */ + struct ip_frag frags[IP_MAX_FRAG_NUM]; /**< fragments */ +} __rte_cache_aligned; diff --git a/bindgen-tests/tests/headers/layout_cmdline_token.h b/bindgen-tests/tests/headers/layout_cmdline_token.h new file mode 100644 index 0000000000..da1bfc2e7a --- /dev/null +++ b/bindgen-tests/tests/headers/layout_cmdline_token.h @@ -0,0 +1,64 @@ +// bindgen-flags: --rustified-enum ".*" + +/** + * Stores a pointer to the ops struct, and the offset: the place to + * write the parsed result in the destination structure. + */ +struct cmdline_token_hdr { + struct cmdline_token_ops *ops; + unsigned int offset; +}; +typedef struct cmdline_token_hdr cmdline_parse_token_hdr_t; + +/** + * A token is defined by this structure. + * + * parse() takes the token as first argument, then the source buffer + * starting at the token we want to parse. The 3rd arg is a pointer + * where we store the parsed data (as binary). It returns the number of + * parsed chars on success and a negative value on error. + * + * complete_get_nb() returns the number of possible values for this + * token if completion is possible. If it is NULL or if it returns 0, + * no completion is possible. + * + * complete_get_elt() copy in dstbuf (the size is specified in the + * parameter) the i-th possible completion for this token. returns 0 + * on success or and a negative value on error. + * + * get_help() fills the dstbuf with the help for the token. It returns + * -1 on error and 0 on success. + */ +struct cmdline_token_ops { + /** parse(token ptr, buf, res pts, buf len) */ + int (*parse)(cmdline_parse_token_hdr_t *, const char *, void *, + unsigned int); + /** return the num of possible choices for this token */ + int (*complete_get_nb)(cmdline_parse_token_hdr_t *); + /** return the elt x for this token (token, idx, dstbuf, size) */ + int (*complete_get_elt)(cmdline_parse_token_hdr_t *, int, char *, + unsigned int); + /** get help for this token (token, dstbuf, size) */ + int (*get_help)(cmdline_parse_token_hdr_t *, char *, unsigned int); +}; + +enum cmdline_numtype { + UINT8 = 0, + UINT16, + UINT32, + UINT64, + INT8, + INT16, + INT32, + INT64 +}; + +struct cmdline_token_num_data { + enum cmdline_numtype type; +}; + +struct cmdline_token_num { + struct cmdline_token_hdr hdr; + struct cmdline_token_num_data num_data; +}; +typedef struct cmdline_token_num cmdline_parse_token_num_t; diff --git a/bindgen-tests/tests/headers/layout_eth_conf.h b/bindgen-tests/tests/headers/layout_eth_conf.h new file mode 100644 index 0000000000..ec1a691985 --- /dev/null +++ b/bindgen-tests/tests/headers/layout_eth_conf.h @@ -0,0 +1,428 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*" +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +typedef unsigned long long uint64_t; + +/** + * Simple flags are used for rte_eth_conf.rxmode.mq_mode. + */ +#define ETH_MQ_RX_RSS_FLAG 0x1 +#define ETH_MQ_RX_DCB_FLAG 0x2 +#define ETH_MQ_RX_VMDQ_FLAG 0x4 + +/* Definitions used for VMDQ and DCB functionality */ +#define ETH_VMDQ_MAX_VLAN_FILTERS 64 /**< Maximum nb. of VMDQ vlan filters. */ +#define ETH_DCB_NUM_USER_PRIORITIES 8 /**< Maximum nb. of DCB priorities. */ +#define ETH_VMDQ_DCB_NUM_QUEUES 128 /**< Maximum nb. of VMDQ DCB queues. */ +#define ETH_DCB_NUM_QUEUES 128 /**< Maximum nb. of DCB queues. */ + +/** + * A set of values to identify what method is to be used to route + * packets to multiple queues. + */ +enum rte_eth_rx_mq_mode { + /** None of DCB,RSS or VMDQ mode */ + ETH_MQ_RX_NONE = 0, + + /** For RX side, only RSS is on */ + ETH_MQ_RX_RSS = ETH_MQ_RX_RSS_FLAG, + /** For RX side,only DCB is on. */ + ETH_MQ_RX_DCB = ETH_MQ_RX_DCB_FLAG, + /** Both DCB and RSS enable */ + ETH_MQ_RX_DCB_RSS = ETH_MQ_RX_RSS_FLAG | ETH_MQ_RX_DCB_FLAG, + + /** Only VMDQ, no RSS nor DCB */ + ETH_MQ_RX_VMDQ_ONLY = ETH_MQ_RX_VMDQ_FLAG, + /** RSS mode with VMDQ */ + ETH_MQ_RX_VMDQ_RSS = ETH_MQ_RX_RSS_FLAG | ETH_MQ_RX_VMDQ_FLAG, + /** Use VMDQ+DCB to route traffic to queues */ + ETH_MQ_RX_VMDQ_DCB = ETH_MQ_RX_VMDQ_FLAG | ETH_MQ_RX_DCB_FLAG, + /** Enable both VMDQ and DCB in VMDq */ + ETH_MQ_RX_VMDQ_DCB_RSS = ETH_MQ_RX_RSS_FLAG | ETH_MQ_RX_DCB_FLAG | + ETH_MQ_RX_VMDQ_FLAG, +}; + +/** + * A structure used to configure the RX features of an Ethernet port. + */ +struct rte_eth_rxmode { + /** The multi-queue packet distribution mode to be used, e.g. RSS. */ + enum rte_eth_rx_mq_mode mq_mode; + uint32_t max_rx_pkt_len; /**< Only used if jumbo_frame enabled. */ + uint16_t split_hdr_size; /**< hdr buf size (header_split enabled).*/ + __extension__ + uint16_t header_split : 1, /**< Header Split enable. */ + hw_ip_checksum : 1, /**< IP/UDP/TCP checksum offload enable. */ + hw_vlan_filter : 1, /**< VLAN filter enable. */ + hw_vlan_strip : 1, /**< VLAN strip enable. */ + hw_vlan_extend : 1, /**< Extended VLAN enable. */ + jumbo_frame : 1, /**< Jumbo Frame Receipt enable. */ + hw_strip_crc : 1, /**< Enable CRC stripping by hardware. */ + enable_scatter : 1, /**< Enable scatter packets rx handler */ + enable_lro : 1; /**< Enable LRO */ +}; + +/** + * A set of values to identify what method is to be used to transmit + * packets using multi-TCs. + */ +enum rte_eth_tx_mq_mode { + ETH_MQ_TX_NONE = 0, /**< It is in neither DCB nor VT mode. */ + ETH_MQ_TX_DCB, /**< For TX side,only DCB is on. */ + ETH_MQ_TX_VMDQ_DCB, /**< For TX side,both DCB and VT is on. */ + ETH_MQ_TX_VMDQ_ONLY, /**< Only VT on, no DCB */ +}; + +/** + * A structure used to configure the TX features of an Ethernet port. + */ +struct rte_eth_txmode { + enum rte_eth_tx_mq_mode mq_mode; /**< TX multi-queues mode. */ + + /* For i40e specifically */ + uint16_t pvid; + __extension__ + uint8_t hw_vlan_reject_tagged : 1, + /**< If set, reject sending out tagged pkts */ + hw_vlan_reject_untagged : 1, + /**< If set, reject sending out untagged pkts */ + hw_vlan_insert_pvid : 1; + /**< If set, enable port based VLAN insertion */ +}; + +/** + * A structure used to configure the Receive Side Scaling (RSS) feature + * of an Ethernet port. + * If not NULL, the *rss_key* pointer of the *rss_conf* structure points + * to an array holding the RSS key to use for hashing specific header + * fields of received packets. The length of this array should be indicated + * by *rss_key_len* below. Otherwise, a default random hash key is used by + * the device driver. + * + * The *rss_key_len* field of the *rss_conf* structure indicates the length + * in bytes of the array pointed by *rss_key*. To be compatible, this length + * will be checked in i40e only. Others assume 40 bytes to be used as before. + * + * The *rss_hf* field of the *rss_conf* structure indicates the different + * types of IPv4/IPv6 packets to which the RSS hashing must be applied. + * Supplying an *rss_hf* equal to zero disables the RSS feature. + */ +struct rte_eth_rss_conf { + uint8_t *rss_key; /**< If not NULL, 40-byte hash key. */ + uint8_t rss_key_len; /**< hash key length in bytes. */ + uint64_t rss_hf; /**< Hash functions to apply - see below. */ +}; + +/** + * This enum indicates the possible number of traffic classes + * in DCB configratioins + */ +enum rte_eth_nb_tcs { + ETH_4_TCS = 4, /**< 4 TCs with DCB. */ + ETH_8_TCS = 8 /**< 8 TCs with DCB. */ +}; + +/** + * This enum indicates the possible number of queue pools + * in VMDQ configurations. + */ +enum rte_eth_nb_pools { + ETH_8_POOLS = 8, /**< 8 VMDq pools. */ + ETH_16_POOLS = 16, /**< 16 VMDq pools. */ + ETH_32_POOLS = 32, /**< 32 VMDq pools. */ + ETH_64_POOLS = 64 /**< 64 VMDq pools. */ +}; + +/** + * A structure used to configure the VMDQ+DCB feature + * of an Ethernet port. + * + * Using this feature, packets are routed to a pool of queues, based + * on the vlan ID in the vlan tag, and then to a specific queue within + * that pool, using the user priority vlan tag field. + * + * A default pool may be used, if desired, to route all traffic which + * does not match the vlan filter rules. + */ +struct rte_eth_vmdq_dcb_conf { + enum rte_eth_nb_pools nb_queue_pools; /**< With DCB, 16 or 32 pools */ + uint8_t enable_default_pool; /**< If non-zero, use a default pool */ + uint8_t default_pool; /**< The default pool, if applicable */ + uint8_t nb_pool_maps; /**< We can have up to 64 filters/mappings */ + struct { + uint16_t vlan_id; /**< The vlan ID of the received frame */ + uint64_t pools; /**< Bitmask of pools for packet rx */ + } pool_map[ETH_VMDQ_MAX_VLAN_FILTERS]; /**< VMDq vlan pool maps. */ + uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES]; + /**< Selects a queue in a pool */ +}; + +/* This structure may be extended in future. */ +struct rte_eth_dcb_rx_conf { + enum rte_eth_nb_tcs nb_tcs; /**< Possible DCB TCs, 4 or 8 TCs */ + /** Traffic class each UP mapped to. */ + uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES]; +}; + +struct rte_eth_vmdq_dcb_tx_conf { + enum rte_eth_nb_pools nb_queue_pools; /**< With DCB, 16 or 32 pools. */ + /** Traffic class each UP mapped to. */ + uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES]; +}; + +struct rte_eth_dcb_tx_conf { + enum rte_eth_nb_tcs nb_tcs; /**< Possible DCB TCs, 4 or 8 TCs. */ + /** Traffic class each UP mapped to. */ + uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES]; +}; + +struct rte_eth_vmdq_tx_conf { + enum rte_eth_nb_pools nb_queue_pools; /**< VMDq mode, 64 pools. */ +}; + +struct rte_eth_vmdq_rx_conf { + enum rte_eth_nb_pools nb_queue_pools; /**< VMDq only mode, 8 or 64 pools */ + uint8_t enable_default_pool; /**< If non-zero, use a default pool */ + uint8_t default_pool; /**< The default pool, if applicable */ + uint8_t enable_loop_back; /**< Enable VT loop back */ + uint8_t nb_pool_maps; /**< We can have up to 64 filters/mappings */ + uint32_t rx_mode; /**< Flags from ETH_VMDQ_ACCEPT_* */ + struct { + uint16_t vlan_id; /**< The vlan ID of the received frame */ + uint64_t pools; /**< Bitmask of pools for packet rx */ + } pool_map[ETH_VMDQ_MAX_VLAN_FILTERS]; /**< VMDq vlan pool maps. */ +}; + +/** + * Flow Director setting modes: none, signature or perfect. + */ +enum rte_fdir_mode { + RTE_FDIR_MODE_NONE = 0, /**< Disable FDIR support. */ + RTE_FDIR_MODE_SIGNATURE, /**< Enable FDIR signature filter mode. */ + RTE_FDIR_MODE_PERFECT, /**< Enable FDIR perfect filter mode. */ + RTE_FDIR_MODE_PERFECT_MAC_VLAN, /**< Enable FDIR filter mode - MAC VLAN. */ + RTE_FDIR_MODE_PERFECT_TUNNEL, /**< Enable FDIR filter mode - tunnel. */ +}; + +/** + * Memory space that can be configured to store Flow Director filters + * in the board memory. + */ +enum rte_fdir_pballoc_type { + RTE_FDIR_PBALLOC_64K = 0, /**< 64k. */ + RTE_FDIR_PBALLOC_128K, /**< 128k. */ + RTE_FDIR_PBALLOC_256K, /**< 256k. */ +}; + +/** + * Select report mode of FDIR hash information in RX descriptors. + */ +enum rte_fdir_status_mode { + RTE_FDIR_NO_REPORT_STATUS = 0, /**< Never report FDIR hash. */ + RTE_FDIR_REPORT_STATUS, /**< Only report FDIR hash for matching pkts. */ + RTE_FDIR_REPORT_STATUS_ALWAYS, /**< Always report FDIR hash. */ +}; + +/** + * A structure used to define the input for IPV4 flow + */ +struct rte_eth_ipv4_flow { + uint32_t src_ip; /**< IPv4 source address in big endian. */ + uint32_t dst_ip; /**< IPv4 destination address in big endian. */ + uint8_t tos; /**< Type of service to match. */ + uint8_t ttl; /**< Time to live to match. */ + uint8_t proto; /**< Protocol, next header in big endian. */ +}; + +/** + * A structure used to define the input for IPV6 flow + */ +struct rte_eth_ipv6_flow { + uint32_t src_ip[4]; /**< IPv6 source address in big endian. */ + uint32_t dst_ip[4]; /**< IPv6 destination address in big endian. */ + uint8_t tc; /**< Traffic class to match. */ + uint8_t proto; /**< Protocol, next header to match. */ + uint8_t hop_limits; /**< Hop limits to match. */ +}; + +/** + * A structure used to configure FDIR masks that are used by the device + * to match the various fields of RX packet headers. + */ +struct rte_eth_fdir_masks { + uint16_t vlan_tci_mask; /**< Bit mask for vlan_tci in big endian */ + /** Bit mask for ipv4 flow in big endian. */ + struct rte_eth_ipv4_flow ipv4_mask; + /** Bit maks for ipv6 flow in big endian. */ + struct rte_eth_ipv6_flow ipv6_mask; + /** Bit mask for L4 source port in big endian. */ + uint16_t src_port_mask; + /** Bit mask for L4 destination port in big endian. */ + uint16_t dst_port_mask; + /** 6 bit mask for proper 6 bytes of Mac address, bit 0 matches the + first byte on the wire */ + uint8_t mac_addr_byte_mask; + /** Bit mask for tunnel ID in big endian. */ + uint32_t tunnel_id_mask; + uint8_t tunnel_type_mask; /**< 1 - Match tunnel type, + 0 - Ignore tunnel type. */ +}; + +/** + * Payload type + */ +enum rte_eth_payload_type { + RTE_ETH_PAYLOAD_UNKNOWN = 0, + RTE_ETH_RAW_PAYLOAD, + RTE_ETH_L2_PAYLOAD, + RTE_ETH_L3_PAYLOAD, + RTE_ETH_L4_PAYLOAD, + RTE_ETH_PAYLOAD_MAX = 8, +}; + +#define RTE_ETH_FDIR_MAX_FLEXLEN 16 /**< Max length of flexbytes. */ +#define RTE_ETH_INSET_SIZE_MAX 128 /**< Max length of input set. */ + +/** + * A structure used to select bytes extracted from the protocol layers to + * flexible payload for filter + */ +struct rte_eth_flex_payload_cfg { + enum rte_eth_payload_type type; /**< Payload type */ + uint16_t src_offset[RTE_ETH_FDIR_MAX_FLEXLEN]; + /**< Offset in bytes from the beginning of packet's payload + src_offset[i] indicates the flexbyte i's offset in original + packet payload. This value should be less than + flex_payload_limit in struct rte_eth_fdir_info.*/ +}; + +/** + * A structure used to define FDIR masks for flexible payload + * for each flow type + */ +struct rte_eth_fdir_flex_mask { + uint16_t flow_type; + uint8_t mask[RTE_ETH_FDIR_MAX_FLEXLEN]; + /**< Mask for the whole flexible payload */ +}; + + +/* + * A packet can be identified by hardware as different flow types. Different + * NIC hardwares may support different flow types. + * Basically, the NIC hardware identifies the flow type as deep protocol as + * possible, and exclusively. For example, if a packet is identified as + * 'RTE_ETH_FLOW_NONFRAG_IPV4_TCP', it will not be any of other flow types, + * though it is an actual IPV4 packet. + * Note that the flow types are used to define RSS offload types in + * rte_ethdev.h. + */ +#define RTE_ETH_FLOW_UNKNOWN 0 +#define RTE_ETH_FLOW_RAW 1 +#define RTE_ETH_FLOW_IPV4 2 +#define RTE_ETH_FLOW_FRAG_IPV4 3 +#define RTE_ETH_FLOW_NONFRAG_IPV4_TCP 4 +#define RTE_ETH_FLOW_NONFRAG_IPV4_UDP 5 +#define RTE_ETH_FLOW_NONFRAG_IPV4_SCTP 6 +#define RTE_ETH_FLOW_NONFRAG_IPV4_OTHER 7 +#define RTE_ETH_FLOW_IPV6 8 +#define RTE_ETH_FLOW_FRAG_IPV6 9 +#define RTE_ETH_FLOW_NONFRAG_IPV6_TCP 10 +#define RTE_ETH_FLOW_NONFRAG_IPV6_UDP 11 +#define RTE_ETH_FLOW_NONFRAG_IPV6_SCTP 12 +#define RTE_ETH_FLOW_NONFRAG_IPV6_OTHER 13 +#define RTE_ETH_FLOW_L2_PAYLOAD 14 +#define RTE_ETH_FLOW_IPV6_EX 15 +#define RTE_ETH_FLOW_IPV6_TCP_EX 16 +#define RTE_ETH_FLOW_IPV6_UDP_EX 17 +#define RTE_ETH_FLOW_PORT 18 + /**< Consider device port number as a flow differentiator */ +#define RTE_ETH_FLOW_VXLAN 19 /**< VXLAN protocol based flow */ +#define RTE_ETH_FLOW_GENEVE 20 /**< GENEVE protocol based flow */ +#define RTE_ETH_FLOW_NVGRE 21 /**< NVGRE protocol based flow */ +#define RTE_ETH_FLOW_MAX 22 + +/** + * A structure used to define all flexible payload related setting + * include flex payload and flex mask + */ +struct rte_eth_fdir_flex_conf { + uint16_t nb_payloads; /**< The number of following payload cfg */ + uint16_t nb_flexmasks; /**< The number of following mask */ + struct rte_eth_flex_payload_cfg flex_set[RTE_ETH_PAYLOAD_MAX]; + /**< Flex payload configuration for each payload type */ + struct rte_eth_fdir_flex_mask flex_mask[RTE_ETH_FLOW_MAX]; + /**< Flex mask configuration for each flow type */ +}; + +/** + * A structure used to configure the Flow Director (FDIR) feature + * of an Ethernet port. + * + * If mode is RTE_FDIR_DISABLE, the pballoc value is ignored. + */ +struct rte_fdir_conf { + enum rte_fdir_mode mode; /**< Flow Director mode. */ + enum rte_fdir_pballoc_type pballoc; /**< Space for FDIR filters. */ + enum rte_fdir_status_mode status; /**< How to report FDIR hash. */ + /** RX queue of packets matching a "drop" filter in perfect mode. */ + uint8_t drop_queue; + struct rte_eth_fdir_masks mask; + struct rte_eth_fdir_flex_conf flex_conf; + /**< Flex payload configuration. */ +}; + +/** + * A structure used to enable/disable specific device interrupts. + */ +struct rte_intr_conf { + /** enable/disable lsc interrupt. 0 (default) - disable, 1 enable */ + uint16_t lsc; + /** enable/disable rxq interrupt. 0 (default) - disable, 1 enable */ + uint16_t rxq; +}; + +/** + * A structure used to configure an Ethernet port. + * Depending upon the RX multi-queue mode, extra advanced + * configuration settings may be needed. + */ +struct rte_eth_conf { + uint32_t link_speeds; /**< bitmap of ETH_LINK_SPEED_XXX of speeds to be + used. ETH_LINK_SPEED_FIXED disables link + autonegotiation, and a unique speed shall be + set. Otherwise, the bitmap defines the set of + speeds to be advertised. If the special value + ETH_LINK_SPEED_AUTONEG (0) is used, all speeds + supported are advertised. */ + struct rte_eth_rxmode rxmode; /**< Port RX configuration. */ + struct rte_eth_txmode txmode; /**< Port TX configuration. */ + uint32_t lpbk_mode; /**< Loopback operation mode. By default the value + is 0, meaning the loopback mode is disabled. + Read the datasheet of given ethernet controller + for details. The possible values of this field + are defined in implementation of each driver. */ + struct { + struct rte_eth_rss_conf rss_conf; /**< Port RSS configuration */ + struct rte_eth_vmdq_dcb_conf vmdq_dcb_conf; + /**< Port vmdq+dcb configuration. */ + struct rte_eth_dcb_rx_conf dcb_rx_conf; + /**< Port dcb RX configuration. */ + struct rte_eth_vmdq_rx_conf vmdq_rx_conf; + /**< Port vmdq RX configuration. */ + } rx_adv_conf; /**< Port RX filtering configuration (union). */ + union { + struct rte_eth_vmdq_dcb_tx_conf vmdq_dcb_tx_conf; + /**< Port vmdq+dcb TX configuration. */ + struct rte_eth_dcb_tx_conf dcb_tx_conf; + /**< Port dcb TX configuration. */ + struct rte_eth_vmdq_tx_conf vmdq_tx_conf; + /**< Port vmdq TX configuration. */ + } tx_adv_conf; /**< Port TX DCB configuration (union). */ + /** Currently,Priority Flow Control(PFC) are supported,if DCB with PFC + is needed,and the variable must be set ETH_DCB_PFC_SUPPORT. */ + uint32_t dcb_capability_en; + struct rte_fdir_conf fdir_conf; /**< FDIR configuration. */ + struct rte_intr_conf intr_conf; /**< Interrupt mode configuration. */ +}; diff --git a/bindgen-tests/tests/headers/layout_kni_mbuf.h b/bindgen-tests/tests/headers/layout_kni_mbuf.h new file mode 100644 index 0000000000..148cb7df95 --- /dev/null +++ b/bindgen-tests/tests/headers/layout_kni_mbuf.h @@ -0,0 +1,31 @@ +#define RTE_CACHE_LINE_MIN_SIZE 64 /**< Minimum Cache line size. */ + +#define RTE_CACHE_LINE_SIZE 64 + +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +typedef unsigned long long uint64_t; + +/* + * The kernel image of the rte_mbuf struct, with only the relevant fields. + * Padding is necessary to assure the offsets of these fields + */ +struct rte_kni_mbuf { + void *buf_addr __attribute__((__aligned__(RTE_CACHE_LINE_SIZE))); + uint64_t buf_physaddr; + char pad0[2]; + uint16_t data_off; /**< Start address of data in segment buffer. */ + char pad1[2]; + uint8_t nb_segs; /**< Number of segments. */ + char pad4[1]; + uint64_t ol_flags; /**< Offload features. */ + char pad2[4]; + uint32_t pkt_len; /**< Total pkt len: sum of all segment data_len. */ + uint16_t data_len; /**< Amount of data in segment buffer. */ + + /* fields on second cache line */ + char pad3[8] __attribute__((__aligned__(RTE_CACHE_LINE_MIN_SIZE))); + void *pool; + void *next; +}; diff --git a/bindgen-tests/tests/headers/layout_large_align_field.h b/bindgen-tests/tests/headers/layout_large_align_field.h new file mode 100644 index 0000000000..f292bb70dc --- /dev/null +++ b/bindgen-tests/tests/headers/layout_large_align_field.h @@ -0,0 +1,99 @@ +// bindgen-flags: --rustified-enum ".*" + +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +typedef unsigned long long uint64_t; + +#define RTE_CACHE_LINE_SIZE 64 + +/** + * Force alignment + */ +#define __rte_aligned(a) __attribute__((__aligned__(a))) + +/** + * Force alignment to cache line. + */ +#define __rte_cache_aligned __rte_aligned(RTE_CACHE_LINE_SIZE) + +#define RTE_LIBRTE_IP_FRAG_MAX_FRAG 4 + +enum { + IP_LAST_FRAG_IDX, /**< index of last fragment */ + IP_FIRST_FRAG_IDX, /**< index of first fragment */ + IP_MIN_FRAG_NUM, /**< minimum number of fragments */ + IP_MAX_FRAG_NUM = RTE_LIBRTE_IP_FRAG_MAX_FRAG, + /**< maximum number of fragments per packet */ +}; + +/** @internal fragmented mbuf */ +struct ip_frag { + uint16_t ofs; /**< offset into the packet */ + uint16_t len; /**< length of fragment */ + struct rte_mbuf *mb; /**< fragment mbuf */ +}; + +/** @internal to uniquely indetify fragmented datagram. */ +struct ip_frag_key { + uint64_t src_dst[4]; /**< src address, first 8 bytes used for IPv4 */ + uint32_t id; /**< dst address */ + uint32_t key_len; /**< src/dst key length */ +}; + +/* + * Tail queue declarations. + */ +#define TAILQ_HEAD(name, type) \ +struct name { \ + struct type *tqh_first; /* first element */ \ + struct type **tqh_last; /* addr of last next element */ \ +} + + +#define TAILQ_ENTRY(type) \ +struct { \ + struct type *tqe_next; /* next element */ \ + struct type **tqe_prev; /* address of previous next element */ \ +} + +/** + * @internal Fragmented packet to reassemble. + * First two entries in the frags[] array are for the last and first fragments. + */ +struct ip_frag_pkt { + TAILQ_ENTRY(ip_frag_pkt) lru; /**< LRU list */ + struct ip_frag_key key; /**< fragmentation key */ + uint64_t start; /**< creation timestamp */ + uint32_t total_size; /**< expected reassembled size */ + uint32_t frag_size; /**< size of fragments received */ + uint32_t last_idx; /**< index of next entry to fill */ + struct ip_frag frags[IP_MAX_FRAG_NUM]; /**< fragments */ +} __rte_cache_aligned; + +TAILQ_HEAD(ip_pkt_list, ip_frag_pkt); /**< @internal fragments tailq */ + +/** fragmentation table statistics */ +struct ip_frag_tbl_stat { + uint64_t find_num; /**< total # of find/insert attempts. */ + uint64_t add_num; /**< # of add ops. */ + uint64_t del_num; /**< # of del ops. */ + uint64_t reuse_num; /**< # of reuse (del/add) ops. */ + uint64_t fail_total; /**< total # of add failures. */ + uint64_t fail_nospace; /**< # of 'no space' add failures. */ +} __rte_cache_aligned; + +/** fragmentation table */ +struct rte_ip_frag_tbl { + uint64_t max_cycles; /**< ttl for table entries. */ + uint32_t entry_mask; /**< hash value mask. */ + uint32_t max_entries; /**< max entries allowed. */ + uint32_t use_entries; /**< entries in use. */ + uint32_t bucket_entries; /**< hash assocaitivity. */ + uint32_t nb_entries; /**< total size of the table. */ + uint32_t nb_buckets; /**< num of associativity lines. */ + struct ip_frag_pkt *last; /**< last used entry. */ + struct ip_pkt_list lru; /**< LRU list for table entries. */ + struct ip_frag_tbl_stat stat; /**< statistics counters. */ + __extension__ struct ip_frag_pkt pkt[0]; /**< hash table. */ +}; diff --git a/bindgen-tests/tests/headers/layout_mbuf.h b/bindgen-tests/tests/headers/layout_mbuf.h new file mode 100644 index 0000000000..0e342f45e0 --- /dev/null +++ b/bindgen-tests/tests/headers/layout_mbuf.h @@ -0,0 +1,188 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq + +#define RTE_CACHE_LINE_MIN_SIZE 64 /**< Minimum Cache line size. */ + +#define RTE_CACHE_LINE_SIZE 64 + +typedef char int8_t; +typedef short int16_t; +typedef int int32_t; +typedef long long int64_t; + +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +typedef unsigned long long uint64_t; + +typedef uint64_t phys_addr_t; + +/** + * Force alignment + */ +#define __rte_aligned(a) __attribute__((__aligned__(a))) + +/** + * Force alignment to cache line. + */ +#define __rte_cache_aligned __rte_aligned(RTE_CACHE_LINE_SIZE) + +/** + * Force minimum cache line alignment. + */ +#define __rte_cache_min_aligned __rte_aligned(RTE_CACHE_LINE_MIN_SIZE) + +/* define a set of marker types that can be used to refer to set points in the + * mbuf */ +__extension__ +typedef void *MARKER[0]; /**< generic marker for a point in a structure */ +__extension__ +typedef uint8_t MARKER8[0]; /**< generic marker with 1B alignment */ +__extension__ +typedef uint64_t MARKER64[0]; /**< marker that allows us to overwrite 8 bytes + * with a single assignment */ + +/** C extension macro for environments lacking C11 features. */ +#if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 201112L +#define RTE_STD_C11 __extension__ +#else +#define RTE_STD_C11 +#endif + +/** + * The atomic counter structure. + */ +typedef struct { + volatile int16_t cnt; /**< An internal counter value. */ +} rte_atomic16_t; + +/** + * The generic rte_mbuf, containing a packet mbuf. + */ +struct rte_mbuf { + MARKER cacheline0; + + void *buf_addr; /**< Virtual address of segment buffer. */ + phys_addr_t buf_physaddr; /**< Physical address of segment buffer. */ + + uint16_t buf_len; /**< Length of segment buffer. */ + + /* next 6 bytes are initialised on RX descriptor rearm */ + MARKER8 rearm_data; + uint16_t data_off; + + /** + * 16-bit Reference counter. + * It should only be accessed using the following functions: + * rte_mbuf_refcnt_update(), rte_mbuf_refcnt_read(), and + * rte_mbuf_refcnt_set(). The functionality of these functions (atomic, + * or non-atomic) is controlled by the CONFIG_RTE_MBUF_REFCNT_ATOMIC + * config option. + */ + RTE_STD_C11 + union { + rte_atomic16_t refcnt_atomic; /**< Atomically accessed refcnt */ + uint16_t refcnt; /**< Non-atomically accessed refcnt */ + }; + uint8_t nb_segs; /**< Number of segments. */ + uint8_t port; /**< Input port. */ + + uint64_t ol_flags; /**< Offload features. */ + + /* remaining bytes are set on RX when pulling packet from descriptor */ + MARKER rx_descriptor_fields1; + + /* + * The packet type, which is the combination of outer/inner L2, L3, L4 + * and tunnel types. The packet_type is about data really present in the + * mbuf. Example: if vlan stripping is enabled, a received vlan packet + * would have RTE_PTYPE_L2_ETHER and not RTE_PTYPE_L2_VLAN because the + * vlan is stripped from the data. + */ + RTE_STD_C11 + union { + uint32_t packet_type; /**< L2/L3/L4 and tunnel information. */ + struct { + uint32_t l2_type:4; /**< (Outer) L2 type. */ + uint32_t l3_type:4; /**< (Outer) L3 type. */ + uint32_t l4_type:4; /**< (Outer) L4 type. */ + uint32_t tun_type:4; /**< Tunnel type. */ + uint32_t inner_l2_type:4; /**< Inner L2 type. */ + uint32_t inner_l3_type:4; /**< Inner L3 type. */ + uint32_t inner_l4_type:4; /**< Inner L4 type. */ + }; + }; + + uint32_t pkt_len; /**< Total pkt len: sum of all segments. */ + uint16_t data_len; /**< Amount of data in segment buffer. */ + /** VLAN TCI (CPU order), valid if PKT_RX_VLAN_STRIPPED is set. */ + uint16_t vlan_tci; + + union { + uint32_t rss; /**< RSS hash result if RSS enabled */ + struct { + RTE_STD_C11 + union { + struct { + uint16_t hash; + uint16_t id; + }; + uint32_t lo; + /**< Second 4 flexible bytes */ + }; + uint32_t hi; + /**< First 4 flexible bytes or FD ID, dependent on + PKT_RX_FDIR_* flag in ol_flags. */ + } fdir; /**< Filter identifier if FDIR enabled */ + struct { + uint32_t lo; + uint32_t hi; + } sched; /**< Hierarchical scheduler */ + uint32_t usr; /**< User defined tags. See rte_distributor_process() */ + } hash; /**< hash information */ + + uint32_t seqn; /**< Sequence number. See also rte_reorder_insert() */ + + /** Outer VLAN TCI (CPU order), valid if PKT_RX_QINQ_STRIPPED is set. */ + uint16_t vlan_tci_outer; + + /* second cache line - fields only used in slow path or on TX */ + MARKER cacheline1 __rte_cache_min_aligned; + + RTE_STD_C11 + union { + void *userdata; /**< Can be used for external metadata */ + uint64_t udata64; /**< Allow 8-byte userdata on 32-bit */ + }; + + struct rte_mempool *pool; /**< Pool from which mbuf was allocated. */ + struct rte_mbuf *next; /**< Next segment of scattered packet. */ + + /* fields to support TX offloads */ + RTE_STD_C11 + union { + uint64_t tx_offload; /**< combined for easy fetch */ + __extension__ + struct { + uint64_t l2_len:7; + /**< L2 (MAC) Header Length for non-tunneling pkt. + * Outer_L4_len + ... + Inner_L2_len for tunneling pkt. + */ + uint64_t l3_len:9; /**< L3 (IP) Header Length. */ + uint64_t l4_len:8; /**< L4 (TCP/UDP) Header Length. */ + uint64_t tso_segsz:16; /**< TCP TSO segment size */ + + /* fields for TX offloading of tunnels */ + uint64_t outer_l3_len:9; /**< Outer L3 (IP) Hdr Length. */ + uint64_t outer_l2_len:7; /**< Outer L2 (MAC) Hdr Length. */ + + /* uint64_t unused:8; */ + }; + }; + + /** Size of the application private data. In case of an indirect + * mbuf, it stores the direct mbuf private data size. */ + uint16_t priv_size; + + /** Timesync flags for use with IEEE1588. */ + uint16_t timesync; +} __rte_cache_aligned; diff --git a/bindgen-tests/tests/headers/long_double.h b/bindgen-tests/tests/headers/long_double.h new file mode 100644 index 0000000000..341be37164 --- /dev/null +++ b/bindgen-tests/tests/headers/long_double.h @@ -0,0 +1,3 @@ +struct foo { + long double bar; +}; diff --git a/bindgen-tests/tests/headers/macro-expr-basic.h b/bindgen-tests/tests/headers/macro-expr-basic.h new file mode 100644 index 0000000000..d2de7fdf49 --- /dev/null +++ b/bindgen-tests/tests/headers/macro-expr-basic.h @@ -0,0 +1,14 @@ +#define FOO 1 +#define BAR 4 +#define BAZ (FOO + BAR) + +#define MIN (1 << 63) + +#define BARR (1 << 0) +#define BAZZ ((1 << 1) + BAZ) +#define I_RAN_OUT_OF_DUMB_NAMES (BARR | BAZZ) + +/* I haz a comment */ +#define HAZ_A_COMMENT BARR + +#define HAZ_A_COMMENT_INSIDE (/* comment for real */ BARR + FOO) diff --git a/bindgen-tests/tests/headers/macro-expr-uncommon-token.h b/bindgen-tests/tests/headers/macro-expr-uncommon-token.h new file mode 100644 index 0000000000..dd1b4343bd --- /dev/null +++ b/bindgen-tests/tests/headers/macro-expr-uncommon-token.h @@ -0,0 +1,7 @@ + +// Commenting this out & removing the usage before `foo` results in the correct +// bindings +#define MODBUS_API +#define MODBUS_WOOT 3 + +MODBUS_API void foo(); diff --git a/bindgen-tests/tests/headers/macro-redef.h b/bindgen-tests/tests/headers/macro-redef.h new file mode 100644 index 0000000000..0180d2ab09 --- /dev/null +++ b/bindgen-tests/tests/headers/macro-redef.h @@ -0,0 +1,5 @@ +#define FOO 4 +#define BAR (1 + FOO) +#undef FOO +#define FOO 5 +#define BAZ (1 + FOO) diff --git a/bindgen-tests/tests/headers/macro_const.h b/bindgen-tests/tests/headers/macro_const.h new file mode 100644 index 0000000000..7c5aa43806 --- /dev/null +++ b/bindgen-tests/tests/headers/macro_const.h @@ -0,0 +1,8 @@ +#define foo "bar" +#define CHAR 'b' +#define CHARR '\0' +#define FLOAT 5.09f +#define FLOAT_EXPR (5 / 1000.0f) +#define LONG 3L + +#define INVALID_UTF8 "\xf0\x28\x8c\x28" diff --git a/bindgen-tests/tests/headers/maddness-is-avoidable.hpp b/bindgen-tests/tests/headers/maddness-is-avoidable.hpp new file mode 100644 index 0000000000..47a7ffbfac --- /dev/null +++ b/bindgen-tests/tests/headers/maddness-is-avoidable.hpp @@ -0,0 +1,9 @@ +// bindgen-flags: --blocklist-type RefPtr_Proxy_member_function + +template +class RefPtr { + template + class Proxy { + typedef R (T::*member_function)(Args...); + }; +}; diff --git a/bindgen-tests/tests/headers/mangling-ios.h b/bindgen-tests/tests/headers/mangling-ios.h new file mode 100644 index 0000000000..d3a0cd787f --- /dev/null +++ b/bindgen-tests/tests/headers/mangling-ios.h @@ -0,0 +1,3 @@ +// bindgen-flags: -- --target=x86_64-apple-ios + +void foo(); diff --git a/bindgen-tests/tests/headers/mangling-linux32.hpp b/bindgen-tests/tests/headers/mangling-linux32.hpp new file mode 100644 index 0000000000..450c91d74a --- /dev/null +++ b/bindgen-tests/tests/headers/mangling-linux32.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: -- --target=i586-unknown-linux + +extern "C" void foo(); + +struct Foo { + static bool sBar; +}; diff --git a/bindgen-tests/tests/headers/mangling-linux64.hpp b/bindgen-tests/tests/headers/mangling-linux64.hpp new file mode 100644 index 0000000000..36dda913e0 --- /dev/null +++ b/bindgen-tests/tests/headers/mangling-linux64.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: -- --target=x86_64-unknown-linux + +extern "C" void foo(); + +struct Foo { + static bool sBar; +}; diff --git a/bindgen-tests/tests/headers/mangling-macos.hpp b/bindgen-tests/tests/headers/mangling-macos.hpp new file mode 100644 index 0000000000..94b16202e5 --- /dev/null +++ b/bindgen-tests/tests/headers/mangling-macos.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: -- --target=x86_64-apple-darwin + +extern "C" void foo(); + +struct Foo { + static bool sBar; +}; diff --git a/bindgen-tests/tests/headers/mangling-win32.hpp b/bindgen-tests/tests/headers/mangling-win32.hpp new file mode 100644 index 0000000000..76a7e664ed --- /dev/null +++ b/bindgen-tests/tests/headers/mangling-win32.hpp @@ -0,0 +1,18 @@ +// bindgen-flags: --raw-line '#![cfg(target = "i686-pc-windows-msvc")]' -- --target=i686-pc-win32 + +extern "C" void foo(); + +struct Foo { + static bool sBar; +}; + +// Also test some x86 Windows specific calling conventions that have their own +// special mangling +extern "C" { + int _fastcall fast_call_func_no_args(); + // This will result in a suffix with more than one character (i.e. `@12`) + int _fastcall fast_call_func_many_args(int,int,int); + int _stdcall std_call_func_no_args(); + // This will result in a suffix with more than one character (i.e. `@12`) + int _stdcall std_call_func_many_args(int,int,int); +} diff --git a/bindgen-tests/tests/headers/mangling-win64.hpp b/bindgen-tests/tests/headers/mangling-win64.hpp new file mode 100644 index 0000000000..8882d7ddd0 --- /dev/null +++ b/bindgen-tests/tests/headers/mangling-win64.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: -- --target=x86_64-pc-win32 + +extern "C" void foo(); + +struct Foo { + static bool sBar; +}; diff --git a/bindgen-tests/tests/headers/merge_extern_blocks_post_1_82.hpp b/bindgen-tests/tests/headers/merge_extern_blocks_post_1_82.hpp new file mode 100644 index 0000000000..080979f17b --- /dev/null +++ b/bindgen-tests/tests/headers/merge_extern_blocks_post_1_82.hpp @@ -0,0 +1,14 @@ +// bindgen-flags: --merge-extern-blocks --enable-cxx-namespaces --rust-target=1.82 -- --target=x86_64-unknown-linux +int foo(); +typedef struct Point { + int x; +} Point; +int bar(); + +namespace ns { + int foo(); + typedef struct Point { + int x; + } Point; + int bar(); +} diff --git a/bindgen-tests/tests/headers/merge_extern_blocks_pre_1_82.hpp b/bindgen-tests/tests/headers/merge_extern_blocks_pre_1_82.hpp new file mode 100644 index 0000000000..779abf174b --- /dev/null +++ b/bindgen-tests/tests/headers/merge_extern_blocks_pre_1_82.hpp @@ -0,0 +1,14 @@ +// bindgen-flags: --merge-extern-blocks --enable-cxx-namespaces --rust-target=1.81 -- --target=x86_64-unknown-linux +int foo(); +typedef struct Point { + int x; +} Point; +int bar(); + +namespace ns { + int foo(); + typedef struct Point { + int x; + } Point; + int bar(); +} diff --git a/bindgen-tests/tests/headers/method-mangling.hpp b/bindgen-tests/tests/headers/method-mangling.hpp new file mode 100644 index 0000000000..0dac497569 --- /dev/null +++ b/bindgen-tests/tests/headers/method-mangling.hpp @@ -0,0 +1,5 @@ + +class Foo { +public: + int type(); +}; diff --git a/bindgen-tests/tests/headers/module-allowlisted.hpp b/bindgen-tests/tests/headers/module-allowlisted.hpp new file mode 100644 index 0000000000..f41e874edd --- /dev/null +++ b/bindgen-tests/tests/headers/module-allowlisted.hpp @@ -0,0 +1,2 @@ +// bindgen-flags: --enable-cxx-namespaces +struct Test {}; diff --git a/bindgen-tests/tests/headers/msvc-no-usr.hpp b/bindgen-tests/tests/headers/msvc-no-usr.hpp new file mode 100644 index 0000000000..b15e49f52d --- /dev/null +++ b/bindgen-tests/tests/headers/msvc-no-usr.hpp @@ -0,0 +1,8 @@ + +typedef unsigned long long size_t; + +class A { + const size_t foo; + + A() : foo(5) {} +}; diff --git a/bindgen-tests/tests/headers/multiple-inherit-empty-correct-layout.hpp b/bindgen-tests/tests/headers/multiple-inherit-empty-correct-layout.hpp new file mode 100644 index 0000000000..1e2b133a0a --- /dev/null +++ b/bindgen-tests/tests/headers/multiple-inherit-empty-correct-layout.hpp @@ -0,0 +1,3 @@ +struct Foo {}; +struct Bar {}; +struct Baz : public Foo, public Bar {}; diff --git a/tests/headers/mutable.hpp b/bindgen-tests/tests/headers/mutable.hpp similarity index 100% rename from tests/headers/mutable.hpp rename to bindgen-tests/tests/headers/mutable.hpp diff --git a/bindgen-tests/tests/headers/namespace.hpp b/bindgen-tests/tests/headers/namespace.hpp new file mode 100644 index 0000000000..7e4197da5f --- /dev/null +++ b/bindgen-tests/tests/headers/namespace.hpp @@ -0,0 +1,51 @@ +// bindgen-flags: --enable-cxx-namespaces --module-raw-line root::whatever 'pub type whatever_other_thing_t = whatever_int_t;' + +void top_level(); + +namespace whatever { + typedef int whatever_int_t; + + void in_whatever(); +} + +namespace { + namespace empty {} + + struct A { + whatever::whatever_int_t b; + }; +} + +template +class C: public A { + T m_c; + T* m_c_ptr; + T m_c_arr[10]; +}; + +template<> +class C; + +namespace w { + typedef unsigned int whatever_int_t; + + template + class D { + C m_c; + }; + + whatever_int_t heh(); // this should return w::whatever_int_t, and not whatever::whatever_int_t + + C foo(); + + C barr(); // <- This is the problematic one +} + +#define NAMESPACE foobar +namespace NAMESPACE { + void foo(); +} + +#include "namespace/nsbegin.h" +void bar(); +#include "namespace/nsend.h" diff --git a/bindgen-tests/tests/headers/namespace/nsbegin.h b/bindgen-tests/tests/headers/namespace/nsbegin.h new file mode 100644 index 0000000000..47a51c93b8 --- /dev/null +++ b/bindgen-tests/tests/headers/namespace/nsbegin.h @@ -0,0 +1 @@ +namespace faraway { diff --git a/bindgen-tests/tests/headers/namespace/nsdefine.h b/bindgen-tests/tests/headers/namespace/nsdefine.h new file mode 100644 index 0000000000..6504fa9f0a --- /dev/null +++ b/bindgen-tests/tests/headers/namespace/nsdefine.h @@ -0,0 +1,4 @@ +#pragma once + +#define BEGIN_NAMESPACE namespace repro { inline namespace __1 { +#define END_NAMESPACE } } diff --git a/bindgen-tests/tests/headers/namespace/nsend.h b/bindgen-tests/tests/headers/namespace/nsend.h new file mode 100644 index 0000000000..5c34318c21 --- /dev/null +++ b/bindgen-tests/tests/headers/namespace/nsend.h @@ -0,0 +1 @@ +} diff --git a/bindgen-tests/tests/headers/nested-class-field.hpp b/bindgen-tests/tests/headers/nested-class-field.hpp new file mode 100644 index 0000000000..295ebe8129 --- /dev/null +++ b/bindgen-tests/tests/headers/nested-class-field.hpp @@ -0,0 +1,7 @@ +class A { + class I; +}; + +class A::I { + int i; +}; diff --git a/bindgen-tests/tests/headers/nested-template-typedef.hpp b/bindgen-tests/tests/headers/nested-template-typedef.hpp new file mode 100644 index 0000000000..8c83de5bae --- /dev/null +++ b/bindgen-tests/tests/headers/nested-template-typedef.hpp @@ -0,0 +1,8 @@ +template +class Foo { +public: + template + struct Bar { + typedef Foo FooU; + }; +}; diff --git a/tests/headers/nested.hpp b/bindgen-tests/tests/headers/nested.hpp similarity index 100% rename from tests/headers/nested.hpp rename to bindgen-tests/tests/headers/nested.hpp diff --git a/tests/headers/nested_vtable.hpp b/bindgen-tests/tests/headers/nested_vtable.hpp similarity index 100% rename from tests/headers/nested_vtable.hpp rename to bindgen-tests/tests/headers/nested_vtable.hpp diff --git a/bindgen-tests/tests/headers/nested_within_namespace.hpp b/bindgen-tests/tests/headers/nested_within_namespace.hpp new file mode 100644 index 0000000000..a9b7c1ec6a --- /dev/null +++ b/bindgen-tests/tests/headers/nested_within_namespace.hpp @@ -0,0 +1,15 @@ +// bindgen-flags: --enable-cxx-namespaces + +namespace foo { + class Bar { + int foo; + + class Baz { + int foo; + }; + }; + + class Baz { + int baz; + }; +} diff --git a/bindgen-tests/tests/headers/new-type-alias.h b/bindgen-tests/tests/headers/new-type-alias.h new file mode 100644 index 0000000000..73de94884c --- /dev/null +++ b/bindgen-tests/tests/headers/new-type-alias.h @@ -0,0 +1,22 @@ +// bindgen-flags: --new-type-alias (Foo|Bar|Baz|Bang) + +// Fake stdint.h and stdbool.h +typedef __UINT64_TYPE__ uint64_t; +#define bool _Bool +#define true 1 + +typedef uint64_t Foo; +static const Foo Foo_A = 1; + +typedef char Bar; +static const Bar Bar_A = 'a'; + +typedef float Baz; +static const Baz Baz_A = 3.25; + +typedef bool Bang; +static const Bang Bang_A = true; + +// Not wrapped +typedef uint64_t Boom; +static const Boom Boom_A = 2; diff --git a/bindgen-tests/tests/headers/newtype-enum.hpp b/bindgen-tests/tests/headers/newtype-enum.hpp new file mode 100644 index 0000000000..e711ed85bc --- /dev/null +++ b/bindgen-tests/tests/headers/newtype-enum.hpp @@ -0,0 +1,8 @@ +// bindgen-flags: --newtype-enum "Foo" -- -std=c++11 + +enum Foo { + Bar = 1 << 1, + Baz = 1 << 2, + Duplicated = 1 << 2, + Negative = -3, +}; diff --git a/bindgen-tests/tests/headers/newtype-global-enum.hpp b/bindgen-tests/tests/headers/newtype-global-enum.hpp new file mode 100644 index 0000000000..c10825fdcf --- /dev/null +++ b/bindgen-tests/tests/headers/newtype-global-enum.hpp @@ -0,0 +1,8 @@ +// bindgen-flags: --newtype-global-enum "Foo" -- -std=c++11 + +enum Foo { + Bar = 1 << 1, + Baz = 1 << 2, + Duplicated = 1 << 2, + Negative = -3, +}; diff --git a/bindgen-tests/tests/headers/no-comments.h b/bindgen-tests/tests/headers/no-comments.h new file mode 100644 index 0000000000..1ddb1a3b1f --- /dev/null +++ b/bindgen-tests/tests/headers/no-comments.h @@ -0,0 +1,5 @@ +// bindgen-flags: --no-doc-comments + +struct Foo { + int s; /*!< Including this will prevent rustc for compiling it */ +}; diff --git a/bindgen-tests/tests/headers/no-derive-debug.h b/bindgen-tests/tests/headers/no-derive-debug.h new file mode 100644 index 0000000000..d11ca0ad92 --- /dev/null +++ b/bindgen-tests/tests/headers/no-derive-debug.h @@ -0,0 +1,15 @@ +// bindgen-flags: --no-derive-debug --blocklist-type foo --raw-line "#[repr(C)] #[derive(Copy, Clone, Default)] pub struct foo { bar: ::std::os::raw::c_int, }" + +struct foo { + int bar; +}; + +/** + * bar should compile. It will normally derive debug, but our blocklist of foo + * and replacement for another type that doesn't implement it would prevent it + * from building if --no-derive-debug didn't work. + */ +struct bar { + struct foo foo; + int baz; +}; diff --git a/bindgen-tests/tests/headers/no-derive-default.h b/bindgen-tests/tests/headers/no-derive-default.h new file mode 100644 index 0000000000..d184ee3a98 --- /dev/null +++ b/bindgen-tests/tests/headers/no-derive-default.h @@ -0,0 +1,15 @@ +// bindgen-flags: --no-derive-default --blocklist-type foo --raw-line "#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct foo { bar: ::std::os::raw::c_int, }" + +struct foo { + int bar; +}; + +/** + * bar should compile. It will normally derive default, but our blocklist of foo + * and replacement for another type that doesn't implement it would prevent it + * from building if --no-derive-default didn't work. + */ +struct bar { + struct foo foo; + int baz; +}; diff --git a/bindgen-tests/tests/headers/no-hash-allowlisted.hpp b/bindgen-tests/tests/headers/no-hash-allowlisted.hpp new file mode 100644 index 0000000000..0f60817da6 --- /dev/null +++ b/bindgen-tests/tests/headers/no-hash-allowlisted.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: --with-derive-hash --allowlist-type "NoHash" --no-hash "NoHash" + +class NoHash { + int i; +}; diff --git a/bindgen-tests/tests/headers/no-hash-opaque.hpp b/bindgen-tests/tests/headers/no-hash-opaque.hpp new file mode 100644 index 0000000000..c1db2cd120 --- /dev/null +++ b/bindgen-tests/tests/headers/no-hash-opaque.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: --with-derive-hash --opaque-type "NoHash" --no-hash "NoHash" + +class NoHash { + int i; +}; diff --git a/bindgen-tests/tests/headers/no-partialeq-allowlisted.hpp b/bindgen-tests/tests/headers/no-partialeq-allowlisted.hpp new file mode 100644 index 0000000000..ced1b42a7b --- /dev/null +++ b/bindgen-tests/tests/headers/no-partialeq-allowlisted.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: --with-derive-partialeq --allowlist-type "NoPartialEq" --no-partialeq "NoPartialEq" + +class NoPartialEq { + int i; +}; diff --git a/bindgen-tests/tests/headers/no-partialeq-opaque.hpp b/bindgen-tests/tests/headers/no-partialeq-opaque.hpp new file mode 100644 index 0000000000..a5a03cd287 --- /dev/null +++ b/bindgen-tests/tests/headers/no-partialeq-opaque.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: --with-derive-partialeq --opaque-type "NoPartialEq" --no-partialeq "NoPartialEq" + +class NoPartialEq { + int i; +}; diff --git a/bindgen-tests/tests/headers/no-recursive-allowlisting.h b/bindgen-tests/tests/headers/no-recursive-allowlisting.h new file mode 100644 index 0000000000..1c6617110b --- /dev/null +++ b/bindgen-tests/tests/headers/no-recursive-allowlisting.h @@ -0,0 +1,7 @@ +// bindgen-flags: --no-recursive-allowlist --allowlist-type "Foo" --raw-line "pub enum Bar {}" --rustified-enum ".*" + +struct Bar; + +struct Foo { + struct Bar* baz; +}; diff --git a/bindgen-tests/tests/headers/no-std.h b/bindgen-tests/tests/headers/no-std.h new file mode 100644 index 0000000000..d98abceddf --- /dev/null +++ b/bindgen-tests/tests/headers/no-std.h @@ -0,0 +1,5 @@ +// bindgen-flags: --ctypes-prefix "libc" --use-core --raw-line "#![no_std]" --raw-line "mod libc { pub type c_int = i32; pub enum c_void {} }" --rustified-enum ".*" +struct foo { + int a, b; + void* bar; +}; diff --git a/tests/headers/no_copy.hpp b/bindgen-tests/tests/headers/no_copy.hpp similarity index 100% rename from tests/headers/no_copy.hpp rename to bindgen-tests/tests/headers/no_copy.hpp diff --git a/bindgen-tests/tests/headers/no_copy_allowlisted.hpp b/bindgen-tests/tests/headers/no_copy_allowlisted.hpp new file mode 100644 index 0000000000..f3b922cae1 --- /dev/null +++ b/bindgen-tests/tests/headers/no_copy_allowlisted.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: --allowlist-type "NoCopy" --no-copy "NoCopy" + +class NoCopy { + int i; +}; diff --git a/bindgen-tests/tests/headers/no_copy_opaque.hpp b/bindgen-tests/tests/headers/no_copy_opaque.hpp new file mode 100644 index 0000000000..c21f213af1 --- /dev/null +++ b/bindgen-tests/tests/headers/no_copy_opaque.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: --opaque-type "NoCopy" --no-copy "NoCopy" + +class NoCopy { + int i; +}; diff --git a/bindgen-tests/tests/headers/no_debug.hpp b/bindgen-tests/tests/headers/no_debug.hpp new file mode 100644 index 0000000000..2017f75da4 --- /dev/null +++ b/bindgen-tests/tests/headers/no_debug.hpp @@ -0,0 +1,6 @@ + +/**
*/ +template +class DebugButWait { + int whatever; +}; diff --git a/bindgen-tests/tests/headers/no_debug_allowlisted.hpp b/bindgen-tests/tests/headers/no_debug_allowlisted.hpp new file mode 100644 index 0000000000..3e3633e475 --- /dev/null +++ b/bindgen-tests/tests/headers/no_debug_allowlisted.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: --allowlist-type "NoDebug" --no-debug "NoDebug" + +class NoDebug { + int i; +}; diff --git a/bindgen-tests/tests/headers/no_debug_bypass_impl_debug.hpp b/bindgen-tests/tests/headers/no_debug_bypass_impl_debug.hpp new file mode 100644 index 0000000000..a586441088 --- /dev/null +++ b/bindgen-tests/tests/headers/no_debug_bypass_impl_debug.hpp @@ -0,0 +1,11 @@ +// bindgen-flags: --no-debug "NoDebug" --impl-debug + +template +class Generic { + T t[40]; +}; + +template +class NoDebug { + T t[40]; +}; diff --git a/bindgen-tests/tests/headers/no_debug_opaque.hpp b/bindgen-tests/tests/headers/no_debug_opaque.hpp new file mode 100644 index 0000000000..d5dc18f773 --- /dev/null +++ b/bindgen-tests/tests/headers/no_debug_opaque.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: --opaque-type "NoDebug" --no-debug "NoDebug" + +class NoDebug { + int i; +}; diff --git a/bindgen-tests/tests/headers/no_default.hpp b/bindgen-tests/tests/headers/no_default.hpp new file mode 100644 index 0000000000..79d25fbdc2 --- /dev/null +++ b/bindgen-tests/tests/headers/no_default.hpp @@ -0,0 +1,11 @@ + +/**
*/ +template +class DefaultButWait { + int whatever; +}; + +template +class DefaultButWaitDerived { + DefaultButWait whatever; +}; diff --git a/bindgen-tests/tests/headers/no_default_allowlisted.hpp b/bindgen-tests/tests/headers/no_default_allowlisted.hpp new file mode 100644 index 0000000000..8a604081f7 --- /dev/null +++ b/bindgen-tests/tests/headers/no_default_allowlisted.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: --allowlist-type "NoDefault" --no-default "NoDefault" + +class NoDefault { + int i; +}; diff --git a/bindgen-tests/tests/headers/no_default_bypass_derive_default.hpp b/bindgen-tests/tests/headers/no_default_bypass_derive_default.hpp new file mode 100644 index 0000000000..0f8339062f --- /dev/null +++ b/bindgen-tests/tests/headers/no_default_bypass_derive_default.hpp @@ -0,0 +1,11 @@ +// bindgen-flags: --no-default "NoDefault" + +template +class Generic { + T t[40]; +}; + +template +class NoDefault { + T t[40]; +}; diff --git a/bindgen-tests/tests/headers/no_default_opaque.hpp b/bindgen-tests/tests/headers/no_default_opaque.hpp new file mode 100644 index 0000000000..3245d8f93c --- /dev/null +++ b/bindgen-tests/tests/headers/no_default_opaque.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: --opaque-type "NoDefault" --no-default "NoDefault" + +class NoDefault { + int i; +}; diff --git a/bindgen-tests/tests/headers/no_size_t_is_usize.h b/bindgen-tests/tests/headers/no_size_t_is_usize.h new file mode 100644 index 0000000000..d4370baf9f --- /dev/null +++ b/bindgen-tests/tests/headers/no_size_t_is_usize.h @@ -0,0 +1,10 @@ +// bindgen-flags: --no-size_t-is-usize + +typedef unsigned long size_t; +typedef long ssize_t; + +struct A { + size_t len; + ssize_t offset; + struct A* next; +}; diff --git a/bindgen-tests/tests/headers/non-type-params.hpp b/bindgen-tests/tests/headers/non-type-params.hpp new file mode 100644 index 0000000000..3e2ccf8e57 --- /dev/null +++ b/bindgen-tests/tests/headers/non-type-params.hpp @@ -0,0 +1,17 @@ +// bindgen-flags: -- -std=c++14 + +template +struct Array { + T elements[Capacity]; +}; + +template +using Array16 = Array; + +using ArrayInt4 = Array; + +struct UsesArray { + Array16 array_char_16; + Array array_bool_8; + ArrayInt4 array_int_4; +}; diff --git a/bindgen-tests/tests/headers/noreturn.hpp b/bindgen-tests/tests/headers/noreturn.hpp new file mode 100644 index 0000000000..bf9d58c7fa --- /dev/null +++ b/bindgen-tests/tests/headers/noreturn.hpp @@ -0,0 +1,6 @@ +// bindgen-flags: --enable-function-attribute-detection -- -std=c++11 +_Noreturn void f(void); +__attribute__((noreturn)) void g(void); +[[noreturn]] void h(void); +void i(__attribute__((noreturn)) void (*arg)(void)); +__attribute__((noreturn)) void j(__attribute__((noreturn)) void (*arg)(void)); diff --git a/bindgen-tests/tests/headers/nsBaseHashtable.hpp b/bindgen-tests/tests/headers/nsBaseHashtable.hpp new file mode 100644 index 0000000000..36a480f20f --- /dev/null +++ b/bindgen-tests/tests/headers/nsBaseHashtable.hpp @@ -0,0 +1,48 @@ +// bindgen-flags: -- -std=c++14 + +using uint32_t = unsigned long; +using size_t = unsigned long long; + +template +class nsBaseHashtableET { +}; + +template +class nsTHashtable { +}; + +template +class nsBaseHashtable + : protected nsTHashtable> +{ + +public: + typedef typename KeyClass::KeyType KeyType; + typedef nsBaseHashtableET EntryType; + + using nsTHashtable::Contains; + using nsTHashtable::GetGeneration; + + nsBaseHashtable() {} + explicit nsBaseHashtable(uint32_t); + + struct LookupResult { + private: + EntryType* mEntry; + nsBaseHashtable& mTable; + + public: + LookupResult(EntryType*, nsBaseHashtable&); + }; + + struct EntryPtr { + private: + EntryType& mEntry; + bool mExistingEntry; + + public: + EntryPtr(nsBaseHashtable&, EntryType*, bool); + ~EntryPtr(); + }; + +}; diff --git a/tests/headers/nsStyleAutoArray.hpp b/bindgen-tests/tests/headers/nsStyleAutoArray.hpp similarity index 97% rename from tests/headers/nsStyleAutoArray.hpp rename to bindgen-tests/tests/headers/nsStyleAutoArray.hpp index 950152c0fd..3049ea210c 100644 --- a/tests/headers/nsStyleAutoArray.hpp +++ b/bindgen-tests/tests/headers/nsStyleAutoArray.hpp @@ -1,3 +1,4 @@ +// bindgen-flags: --rustified-enum ".*" template class nsTArray { diff --git a/bindgen-tests/tests/headers/objc_allowlist.h b/bindgen-tests/tests/headers/objc_allowlist.h new file mode 100644 index 0000000000..b5406d0adf --- /dev/null +++ b/bindgen-tests/tests/headers/objc_allowlist.h @@ -0,0 +1,24 @@ +// bindgen-flags: --allowlist-type IAllowlistMe --allowlist-type AllowlistMe_InterestingCategory -- -x objective-c +// bindgen-osx-only + + +// Protocol should be included, since it is used by the AllowlistMe +@protocol SomeProtocol +-(void)protocolMethod; ++(void)protocolClassMethod; +@end + +// The allowlisted item +@interface AllowlistMe +-(void)method; ++(void)classMethod; +@end + +// This was also explicitly allowlisted +@interface AllowlistMe (InterestingCategory) +@end + +// This was not automatically allowlisted +@interface AllowlistMe (IgnoredCategory) +@end + diff --git a/bindgen-tests/tests/headers/objc_blocklist.h b/bindgen-tests/tests/headers/objc_blocklist.h new file mode 100644 index 0000000000..605f2993cf --- /dev/null +++ b/bindgen-tests/tests/headers/objc_blocklist.h @@ -0,0 +1,9 @@ +// bindgen-flags: --objc-extern-crate --blocklist-item ISomeClass::class_ambiguouslyBlockedMethod --blocklist-item ISomeClass::blockedInstanceMethod -- -x objective-c +// bindgen-osx-only + +@interface SomeClass ++ (void)ambiguouslyBlockedMethod; +- (void)ambiguouslyBlockedMethod; +- (void)instanceMethod; +- (void)blockedInstanceMethod; +@end diff --git a/bindgen-tests/tests/headers/objc_category.h b/bindgen-tests/tests/headers/objc_category.h new file mode 100644 index 0000000000..b8e60d5fa9 --- /dev/null +++ b/bindgen-tests/tests/headers/objc_category.h @@ -0,0 +1,10 @@ +// bindgen-flags: -- -x objective-c +// bindgen-osx-only + +@interface Foo +-(void)method; +@end + +@interface Foo (BarCategory) +-(void)categoryMethod; +@end diff --git a/bindgen-tests/tests/headers/objc_class.h b/bindgen-tests/tests/headers/objc_class.h new file mode 100644 index 0000000000..f5ec950750 --- /dev/null +++ b/bindgen-tests/tests/headers/objc_class.h @@ -0,0 +1,10 @@ +// bindgen-flags: -- -x objective-c +// bindgen-osx-only + +@class Foo; + +Foo* fooVar; + +@interface Foo +-(void)method; +@end diff --git a/bindgen-tests/tests/headers/objc_class_method.h b/bindgen-tests/tests/headers/objc_class_method.h new file mode 100644 index 0000000000..1a68ed3e6e --- /dev/null +++ b/bindgen-tests/tests/headers/objc_class_method.h @@ -0,0 +1,11 @@ +// bindgen-flags: -- -x objective-c +// bindgen-osx-only + +@interface Foo ++ (void)method; ++ (void)methodWithInt:(int)foo; ++ (void)methodWithFoo:(Foo*)foo; ++ (int)methodReturningInt; ++ (Foo*)methodReturningFoo; ++ (void)methodWithArg1:(int)intvalue andArg2:(char*)ptr andArg3:(float)floatvalue; +@end diff --git a/bindgen-tests/tests/headers/objc_escape.h b/bindgen-tests/tests/headers/objc_escape.h new file mode 100644 index 0000000000..2d21bd5481 --- /dev/null +++ b/bindgen-tests/tests/headers/objc_escape.h @@ -0,0 +1,13 @@ +// bindgen-flags: -- -x objective-c +// bindgen-osx-only + +@interface A +-(void)f:(int)arg1 as:(int)arg2; +-(void)crate:(int)self; +@end + +@interface B + +@property(nonatomic, retain) id type; + +@end diff --git a/bindgen-tests/tests/headers/objc_inheritance.h b/bindgen-tests/tests/headers/objc_inheritance.h new file mode 100644 index 0000000000..985f1597e5 --- /dev/null +++ b/bindgen-tests/tests/headers/objc_inheritance.h @@ -0,0 +1,11 @@ +// bindgen-flags: -- -x objective-c +// bindgen-osx-only + +@interface Foo +@end + +@interface Bar: Foo +@end + +@interface Baz: Bar +@end diff --git a/bindgen-tests/tests/headers/objc_interface.h b/bindgen-tests/tests/headers/objc_interface.h new file mode 100644 index 0000000000..df16e921ec --- /dev/null +++ b/bindgen-tests/tests/headers/objc_interface.h @@ -0,0 +1,8 @@ +// bindgen-flags: -- -x objective-c +// bindgen-osx-only + +@interface Foo +@end + +@protocol bar +@end diff --git a/bindgen-tests/tests/headers/objc_interface_type.h b/bindgen-tests/tests/headers/objc_interface_type.h new file mode 100644 index 0000000000..4667ce2a0c --- /dev/null +++ b/bindgen-tests/tests/headers/objc_interface_type.h @@ -0,0 +1,13 @@ +// bindgen-flags: -- -x objective-c +// bindgen-osx-only + +@interface Foo +@end + +struct FooStruct { + Foo *foo; +}; + +void fooFunc(Foo *foo); + +static const Foo *kFoo; diff --git a/bindgen-tests/tests/headers/objc_method.h b/bindgen-tests/tests/headers/objc_method.h new file mode 100644 index 0000000000..b89d1621b1 --- /dev/null +++ b/bindgen-tests/tests/headers/objc_method.h @@ -0,0 +1,15 @@ +// bindgen-flags: -- -x objective-c +// bindgen-osx-only + +@interface Foo +- (void)method; +- (void)methodWithInt:(int)foo; +- (void)methodWithFoo:(Foo*)foo; +- (int)methodReturningInt; +- (Foo*)methodReturningFoo; +- (void)methodWithArg1:(int)intvalue andArg2:(char*)ptr andArg3:(float)floatvalue; +- (instancetype)methodWithAndWithoutKeywords:(int)arg1 + arg2Name:(float)arg2 + :(float)arg3 + arg4Name:(int)arg4; +@end diff --git a/bindgen-tests/tests/headers/objc_method_clash.h b/bindgen-tests/tests/headers/objc_method_clash.h new file mode 100644 index 0000000000..d99d3691fe --- /dev/null +++ b/bindgen-tests/tests/headers/objc_method_clash.h @@ -0,0 +1,7 @@ +// bindgen-flags: -- -x objective-c +// bindgen-osx-only + +@interface Foo ++ (void)foo; +- (void)foo; +@end diff --git a/bindgen-tests/tests/headers/objc_pointer_return_types.h b/bindgen-tests/tests/headers/objc_pointer_return_types.h new file mode 100644 index 0000000000..4d1a6dea34 --- /dev/null +++ b/bindgen-tests/tests/headers/objc_pointer_return_types.h @@ -0,0 +1,10 @@ +// bindgen-flags: -- -x objective-c +// bindgen-osx-only + +@interface Bar +@end + +@interface Foo ++ (Bar*)methodReturningBar; +- (void)methodUsingBar:(Bar *)my_bar; +@end diff --git a/bindgen-tests/tests/headers/objc_property_fnptr.h b/bindgen-tests/tests/headers/objc_property_fnptr.h new file mode 100644 index 0000000000..fe3e7fcc99 --- /dev/null +++ b/bindgen-tests/tests/headers/objc_property_fnptr.h @@ -0,0 +1,6 @@ +// bindgen-flags: -- -x objective-c +// bindgen-osx-only + +@interface Foo +@property int (*func)(char, short, float); +@end diff --git a/bindgen-tests/tests/headers/objc_protocol.h b/bindgen-tests/tests/headers/objc_protocol.h new file mode 100644 index 0000000000..46978a3b4e --- /dev/null +++ b/bindgen-tests/tests/headers/objc_protocol.h @@ -0,0 +1,8 @@ +// bindgen-flags: -- -x objective-c +// bindgen-osx-only + +@protocol Foo +@end + +@interface Foo +@end diff --git a/bindgen-tests/tests/headers/objc_protocol_inheritance.h b/bindgen-tests/tests/headers/objc_protocol_inheritance.h new file mode 100644 index 0000000000..13135fddbc --- /dev/null +++ b/bindgen-tests/tests/headers/objc_protocol_inheritance.h @@ -0,0 +1,11 @@ +// bindgen-flags: -- -x objective-c +// bindgen-osx-only + +@protocol Foo +@end + +@interface Foo +@end + +@interface Bar : Foo +@end diff --git a/bindgen-tests/tests/headers/objc_sel_and_id.h b/bindgen-tests/tests/headers/objc_sel_and_id.h new file mode 100644 index 0000000000..6491a541c6 --- /dev/null +++ b/bindgen-tests/tests/headers/objc_sel_and_id.h @@ -0,0 +1,7 @@ +// bindgen-flags: -- -x objective-c +// bindgen-osx-only + +id object; +SEL selector; + +void f(id object, SEL selector); diff --git a/bindgen-tests/tests/headers/objc_template.h b/bindgen-tests/tests/headers/objc_template.h new file mode 100644 index 0000000000..b616da013f --- /dev/null +++ b/bindgen-tests/tests/headers/objc_template.h @@ -0,0 +1,10 @@ +// bindgen-flags: -- -x objective-c +// bindgen-osx-only + +@interface Foo<__covariant ObjectType> +- (ObjectType)get; +@end + +@interface FooMultiGeneric<__covariant KeyType, __covariant ObjectType> +- (nullable ObjectType)objectForKey:(KeyType)key; +@end diff --git a/bindgen-tests/tests/headers/only_bitfields.hpp b/bindgen-tests/tests/headers/only_bitfields.hpp new file mode 100644 index 0000000000..793bc66b62 --- /dev/null +++ b/bindgen-tests/tests/headers/only_bitfields.hpp @@ -0,0 +1,4 @@ +class C { + bool a: 1; + bool b: 7; +}; diff --git a/bindgen-tests/tests/headers/opaque-template-inst-member-2.hpp b/bindgen-tests/tests/headers/opaque-template-inst-member-2.hpp new file mode 100644 index 0000000000..85b648ffb8 --- /dev/null +++ b/bindgen-tests/tests/headers/opaque-template-inst-member-2.hpp @@ -0,0 +1,20 @@ +// bindgen-flags: --opaque-type 'OpaqueTemplate' --with-derive-hash --with-derive-partialeq --with-derive-eq + +/// This is like `opaque-template-inst-member.hpp` except exercising the cases +/// where we are OK to derive Debug/Hash/PartialEq. + +template +class OpaqueTemplate { + T mData; +}; + +/// Should derive Debug/Hash/PartialEq. +class ContainsOpaqueTemplate { + OpaqueTemplate mBlah; + int mBaz; +}; + +/// Should also derive Debug/Hash/PartialEq. +class InheritsOpaqueTemplate : public OpaqueTemplate { + char* wow; +}; diff --git a/bindgen-tests/tests/headers/opaque-template-inst-member.hpp b/bindgen-tests/tests/headers/opaque-template-inst-member.hpp new file mode 100644 index 0000000000..6516aa564d --- /dev/null +++ b/bindgen-tests/tests/headers/opaque-template-inst-member.hpp @@ -0,0 +1,20 @@ +// bindgen-flags: --opaque-type 'OpaqueTemplate' --with-derive-hash --with-derive-partialeq --impl-partialeq --with-derive-eq + +template +class OpaqueTemplate { + T mData; + bool mCannotDebug[400]; +}; + +/// This should not end up deriving Debug/Hash because its `mBlah` field cannot derive +/// Debug/Hash because the instantiation's definition cannot derive Debug/Hash. +class ContainsOpaqueTemplate { + OpaqueTemplate mBlah; + int mBaz; +}; + +/// This should not end up deriving Debug/Hash either, for similar reasons, although +/// we're exercising base member edges now. +class InheritsOpaqueTemplate : public OpaqueTemplate { + char* wow; +}; diff --git a/bindgen-tests/tests/headers/opaque-template-instantiation-namespaced.hpp b/bindgen-tests/tests/headers/opaque-template-instantiation-namespaced.hpp new file mode 100644 index 0000000000..e1cadcc2a9 --- /dev/null +++ b/bindgen-tests/tests/headers/opaque-template-instantiation-namespaced.hpp @@ -0,0 +1,29 @@ +// bindgen-flags: --enable-cxx-namespaces --opaque-type 'zoidberg::Template' --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++14 + +namespace zoidberg { + +template +class Template { + T member; +}; + +struct Foo { + char c; +}; + +struct Bar { + int i; +}; + +class ContainsInstantiation { + Template not_opaque; +}; + +class ContainsOpaqueInstantiation { + // We should not generate a layout test for this instantiation, and it + // should appear as an opaque blob of bytes in + // `ContainsOpaqueInstantiation`'s type definition. + Template opaque; +}; + +} diff --git a/bindgen-tests/tests/headers/opaque-template-instantiation.hpp b/bindgen-tests/tests/headers/opaque-template-instantiation.hpp new file mode 100644 index 0000000000..fff49af287 --- /dev/null +++ b/bindgen-tests/tests/headers/opaque-template-instantiation.hpp @@ -0,0 +1,17 @@ +// bindgen-flags: --opaque-type 'Template' --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++14 + +template +class Template { + T member; +}; + +class ContainsInstantiation { + Template not_opaque; +}; + +class ContainsOpaqueInstantiation { + // We should not generate a layout test for this instantiation, and it + // should appear as an opaque blob of bytes in + // `ContainsOpaqueInstantiation`'s type definition. + Template opaque; +}; diff --git a/bindgen-tests/tests/headers/opaque-tracing.hpp b/bindgen-tests/tests/headers/opaque-tracing.hpp new file mode 100644 index 0000000000..cf65276a68 --- /dev/null +++ b/bindgen-tests/tests/headers/opaque-tracing.hpp @@ -0,0 +1,21 @@ +// bindgen-flags: --opaque-type ".*" --allowlist-function=foo --with-derive-hash --with-derive-partialeq --with-derive-eq + +class Container; + +// The allowlist tracing should reach the Container type, even though it's +// marked as opaque. +void foo(Container* c); + +template +class Wat { + T foo; +}; + +class OtherOpaque { + int bar; +}; + +class Container { + Wat bar; + OtherOpaque baz; +}; diff --git a/bindgen-tests/tests/headers/opaque_in_struct.hpp b/bindgen-tests/tests/headers/opaque_in_struct.hpp new file mode 100644 index 0000000000..12910e1f77 --- /dev/null +++ b/bindgen-tests/tests/headers/opaque_in_struct.hpp @@ -0,0 +1,11 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq + + +/**
*/ +typedef struct opaque { + int waht; +} opaque; + +struct container { + opaque contained; +}; diff --git a/tests/headers/opaque_pointer.hpp b/bindgen-tests/tests/headers/opaque_pointer.hpp similarity index 78% rename from tests/headers/opaque_pointer.hpp rename to bindgen-tests/tests/headers/opaque_pointer.hpp index 53f8ce1fa8..008689859b 100644 --- a/tests/headers/opaque_pointer.hpp +++ b/bindgen-tests/tests/headers/opaque_pointer.hpp @@ -1,3 +1,4 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq /** *
diff --git a/bindgen-tests/tests/headers/opaque_typedef.hpp b/bindgen-tests/tests/headers/opaque_typedef.hpp new file mode 100644 index 0000000000..878d5bcbc1 --- /dev/null +++ b/bindgen-tests/tests/headers/opaque_typedef.hpp @@ -0,0 +1,17 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++11 +template +class RandomTemplate; + +template +class Wat; + +template +class Wat3; + +template<> +class Wat3<3>; + +/**
*/ +typedef RandomTemplate ShouldBeOpaque; + +typedef RandomTemplate ShouldNotBeOpaque; diff --git a/bindgen-tests/tests/headers/opencl_vector.h b/bindgen-tests/tests/headers/opencl_vector.h new file mode 100644 index 0000000000..79022c768f --- /dev/null +++ b/bindgen-tests/tests/headers/opencl_vector.h @@ -0,0 +1,9 @@ +typedef float float4 __attribute__((ext_vector_type(4))); +typedef float float2 __attribute__((ext_vector_type(2))); + +float4 foo(float2 a, float2 b) { + float4 c; + c.xz = a; + c.yw = b; + return c; +} \ No newline at end of file diff --git a/bindgen-tests/tests/headers/operator.hpp b/bindgen-tests/tests/headers/operator.hpp new file mode 100644 index 0000000000..186f1fe683 --- /dev/null +++ b/bindgen-tests/tests/headers/operator.hpp @@ -0,0 +1,5 @@ +int operator_information(void); + +class Foo; +int operator<<(const Foo&, int); + diff --git a/bindgen-tests/tests/headers/operator_equals.hpp b/bindgen-tests/tests/headers/operator_equals.hpp new file mode 100644 index 0000000000..38a3a092a9 --- /dev/null +++ b/bindgen-tests/tests/headers/operator_equals.hpp @@ -0,0 +1,9 @@ +// bindgen-flags: --represent-cxx-operators --generate-inline-functions -- -x c++ +// bindgen-parse-callbacks: operator-rename + +class SomeClass { +public: + bool operator=(const SomeClass& another) { + return false; + } +}; diff --git a/bindgen-tests/tests/headers/ord-enum.h b/bindgen-tests/tests/headers/ord-enum.h new file mode 100644 index 0000000000..b14e77c2f8 --- /dev/null +++ b/bindgen-tests/tests/headers/ord-enum.h @@ -0,0 +1,15 @@ +// bindgen-flags: --rustified-enum ".*" --with-derive-ord + +enum A { + A0 = 0, + A1 = 1, + A2 = 2, + A3 = A0 - 1, +}; + +enum B { + B0 = 1, + B1 = B0 + 3, + B2 = B0 + 2, + B3 = B0 - 2, +}; diff --git a/bindgen-tests/tests/headers/overflowed_enum.hpp b/bindgen-tests/tests/headers/overflowed_enum.hpp new file mode 100644 index 0000000000..18d3fe4173 --- /dev/null +++ b/bindgen-tests/tests/headers/overflowed_enum.hpp @@ -0,0 +1,12 @@ +// bindgen-flags: --rustified-enum ".*" -- -std=c++11 -Wno-narrowing + +enum Foo { + BAP_ARM = 0x93fcb9, + BAP_X86 = 0xb67eed, + BAP_X86_64 = 0xba7b274f, +}; + +enum Bar: unsigned short { + One = 1, + Big = 65538, +}; diff --git a/bindgen-tests/tests/headers/overloading.hpp b/bindgen-tests/tests/headers/overloading.hpp new file mode 100644 index 0000000000..3c2b04875b --- /dev/null +++ b/bindgen-tests/tests/headers/overloading.hpp @@ -0,0 +1,9 @@ +extern bool Evaluate(char r); +extern bool Evaluate(int x, int y); + +namespace foo { + extern void MyFunction(); +} +namespace bar { + extern void MyFunction(); +} diff --git a/bindgen-tests/tests/headers/packed-bitfield.h b/bindgen-tests/tests/headers/packed-bitfield.h new file mode 100644 index 0000000000..ef23bc6ad2 --- /dev/null +++ b/bindgen-tests/tests/headers/packed-bitfield.h @@ -0,0 +1,5 @@ +struct Date { + unsigned char day: 5; + unsigned char month: 4; + signed short year: 15; +} __attribute__((packed)); diff --git a/bindgen-tests/tests/headers/packed-n-with-padding.h b/bindgen-tests/tests/headers/packed-n-with-padding.h new file mode 100644 index 0000000000..8a6233b52b --- /dev/null +++ b/bindgen-tests/tests/headers/packed-n-with-padding.h @@ -0,0 +1,8 @@ +#pragma pack(push, 2) +struct Packed { + char a; + short b; + char c; + int d; +}; +#pragma pack(pop) diff --git a/bindgen-tests/tests/headers/packed-vtable.h b/bindgen-tests/tests/headers/packed-vtable.h new file mode 100644 index 0000000000..b3405977b5 --- /dev/null +++ b/bindgen-tests/tests/headers/packed-vtable.h @@ -0,0 +1,10 @@ +// bindgen-flags: --raw-line '#![cfg(feature = "nightly")]' -- -x c++ -std=c++11 + +#pragma pack(1) + +// This should be packed. +struct PackedVtable { + virtual ~PackedVtable(); +}; + +#pragma pack() diff --git a/bindgen-tests/tests/headers/parm-union.hpp b/bindgen-tests/tests/headers/parm-union.hpp new file mode 100644 index 0000000000..e36df69120 --- /dev/null +++ b/bindgen-tests/tests/headers/parm-union.hpp @@ -0,0 +1,4 @@ +struct Struct +{ + void Function(union Union&); +}; diff --git a/bindgen-tests/tests/headers/parsecb-anonymous-enum-variant-rename.h b/bindgen-tests/tests/headers/parsecb-anonymous-enum-variant-rename.h new file mode 100644 index 0000000000..9336cf8993 --- /dev/null +++ b/bindgen-tests/tests/headers/parsecb-anonymous-enum-variant-rename.h @@ -0,0 +1,6 @@ +// bindgen-flags: --allowlist-var ^MyVal$ +// bindgen-parse-callbacks: enum-variant-rename + +enum { + MyVal = 0, +}; diff --git a/bindgen-tests/tests/headers/partial-specialization-and-inheritance.hpp b/bindgen-tests/tests/headers/partial-specialization-and-inheritance.hpp new file mode 100644 index 0000000000..4eb8f54583 --- /dev/null +++ b/bindgen-tests/tests/headers/partial-specialization-and-inheritance.hpp @@ -0,0 +1,40 @@ +// bindgen-unstable + +// This was originally a test case generated by creducing errors in SpiderMonkey +// bindings generation. I've tried to make it understandable by giving more +// meaningful names to everything, and a couple comments. +// +// We don't support partial template specialization, but we *should* +// successfully parse this header, and generate bindings for it, but the usage +// of the partial template specialization should result in opaque blobs. + +// A base class providing a method. +template +class Base { +public: + void some_method(T, T); +}; + +// A template with a default representation. +template +class Derived { + bool b; +}; + +// A partial specialization for pointers. Note that this should have a different +// and larger layout than the template it is specializing. +template +class Derived : public Base { + int x; + int y; +}; + +// A struct that uses the partial specialization and method from the partial +// specialization's base class. +struct Usage { + Usage() { + static_member.some_method(this, this); + } + + static Derived static_member; +}; diff --git a/bindgen-tests/tests/headers/pointer-attr.h b/bindgen-tests/tests/headers/pointer-attr.h new file mode 100644 index 0000000000..fe0004b8bf --- /dev/null +++ b/bindgen-tests/tests/headers/pointer-attr.h @@ -0,0 +1 @@ +void a(const char __attribute__((btf_type_tag("a"))) *); diff --git a/bindgen-tests/tests/headers/prefix-link-name-c.h b/bindgen-tests/tests/headers/prefix-link-name-c.h new file mode 100644 index 0000000000..2432798fce --- /dev/null +++ b/bindgen-tests/tests/headers/prefix-link-name-c.h @@ -0,0 +1,4 @@ +// bindgen-parse-callbacks: prefix-link-name-foo_ +// bindgen-flags: --prefix-link-name foo_ + +int bar(void); diff --git a/bindgen-tests/tests/headers/prefix-link-name-cpp.hpp b/bindgen-tests/tests/headers/prefix-link-name-cpp.hpp new file mode 100644 index 0000000000..4fd2612327 --- /dev/null +++ b/bindgen-tests/tests/headers/prefix-link-name-cpp.hpp @@ -0,0 +1,8 @@ +// bindgen-parse-callbacks: prefix-link-name-foo_ +// bindgen-flags: --prefix-link-name foo_ + +namespace baz { + +int foo(); + +} // end namespace baz diff --git a/bindgen-tests/tests/headers/prepend-enum-constified-variant.h b/bindgen-tests/tests/headers/prepend-enum-constified-variant.h new file mode 100644 index 0000000000..e9ba0e732b --- /dev/null +++ b/bindgen-tests/tests/headers/prepend-enum-constified-variant.h @@ -0,0 +1,6 @@ +// bindgen-flags: --no-prepend-enum-name --rustified-enum ".*" + +enum AVCodecID { + AV_CODEC_ID_FIRST_UNKNOWN = 0x18000, + AV_CODEC_ID_TTF = 0x18000, +}; diff --git a/bindgen-tests/tests/headers/prepend_enum_name.hpp b/bindgen-tests/tests/headers/prepend_enum_name.hpp new file mode 100644 index 0000000000..e766036960 --- /dev/null +++ b/bindgen-tests/tests/headers/prepend_enum_name.hpp @@ -0,0 +1,6 @@ +// bindgen-flags: --no-prepend-enum-name + +enum foo { + FOO_BAR, + FOO_BAZ, +}; diff --git a/tests/headers/private.hpp b/bindgen-tests/tests/headers/private.hpp similarity index 100% rename from tests/headers/private.hpp rename to bindgen-tests/tests/headers/private.hpp diff --git a/bindgen-tests/tests/headers/private_fields.hpp b/bindgen-tests/tests/headers/private_fields.hpp new file mode 100644 index 0000000000..965acde9e8 --- /dev/null +++ b/bindgen-tests/tests/headers/private_fields.hpp @@ -0,0 +1,63 @@ +// bindgen-flags: --respect-cxx-access-specs +// bindgen-parse-callbacks: field-visibility-default-public + +class PubPriv { + public: + int x; + private: + int y; +}; + +class PrivateBitFields { + unsigned int a : 4; + unsigned int b : 4; +}; +class PublicBitFields { + public: + unsigned int a : 4; + unsigned int b : 4; +}; +class MixedBitFields { + unsigned int a : 4; + public: + unsigned int d : 4; +}; + +class Base { + public: + int member; +}; + +class InheritsPrivately : Base {}; +class InheritsPublically : public Base {}; + +class WithAnonStruct { + struct { + int a; + }; + public: + struct { + int b; + }; +}; + +class WithAnonUnion { + union {}; +}; + +class Override { + public: + unsigned int a; + // override with annotation + /**
*/ + unsigned int b; + // override with callback + unsigned int private_c; + + unsigned int bf_a : 4; + // override with annotation + /**
*/ + unsigned int bf_b : 4; + // override with callback + unsigned int private_bf_c : 4; +}; diff --git a/bindgen-tests/tests/headers/ptr32-has-different-size.h b/bindgen-tests/tests/headers/ptr32-has-different-size.h new file mode 100644 index 0000000000..8cda702c53 --- /dev/null +++ b/bindgen-tests/tests/headers/ptr32-has-different-size.h @@ -0,0 +1,4 @@ +// bindgen-flags: -- -fms-extensions +typedef struct TEST_STRUCT { + void* __ptr32 ptr_32bit; +} TEST; diff --git a/bindgen-tests/tests/headers/public-dtor.hpp b/bindgen-tests/tests/headers/public-dtor.hpp new file mode 100644 index 0000000000..60d69d799f --- /dev/null +++ b/bindgen-tests/tests/headers/public-dtor.hpp @@ -0,0 +1,18 @@ + +namespace cv { + class Foo { + public: + ~Foo(); + }; + + Foo::~Foo() {} + + class Bar { + public: + ~Bar(); + }; + + inline + Bar::~Bar() {} + +} diff --git a/bindgen-tests/tests/headers/qualified-dependent-types.hpp b/bindgen-tests/tests/headers/qualified-dependent-types.hpp new file mode 100644 index 0000000000..fcdfc87c81 --- /dev/null +++ b/bindgen-tests/tests/headers/qualified-dependent-types.hpp @@ -0,0 +1,16 @@ +// Issue #2085. + +template +struct Foo; + +template +struct Bar {}; + +template +struct Bar { + using BarDependent = typename Foo::Dependent; + void method(const BarDependent &); +}; + +template +void Bar::method(const BarDependent &) {} diff --git a/tests/headers/redeclaration.hpp b/bindgen-tests/tests/headers/redeclaration.hpp similarity index 100% rename from tests/headers/redeclaration.hpp rename to bindgen-tests/tests/headers/redeclaration.hpp diff --git a/bindgen-tests/tests/headers/redundant-packed-and-align.h b/bindgen-tests/tests/headers/redundant-packed-and-align.h new file mode 100644 index 0000000000..75e15e4139 --- /dev/null +++ b/bindgen-tests/tests/headers/redundant-packed-and-align.h @@ -0,0 +1,42 @@ +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +typedef unsigned long long uint64_t; + +struct redundant_packed { + uint32_t a; + uint32_t b; +} __attribute__((packed, aligned(8))); + +struct redundant_packed_bitfield { + uint8_t a[3]; + uint8_t b0:1; + uint8_t b1:1; + uint32_t c; +} __attribute__((packed, aligned(8))); + + +union redundant_packed_union { + uint64_t a; + uint32_t b; +} __attribute__((packed, aligned(16))); + + +struct inner { + uint8_t a; +} __attribute__((packed, aligned(2))); + +struct outer_redundant_packed { + struct inner a[2]; + uint32_t b; +} __attribute__((packed, aligned(8))); + + +#pragma pack(2) + +struct redundant_pragma_packed { + uint8_t a; + uint16_t b; +} __attribute__((aligned(4))); + +#pragma pack() diff --git a/bindgen-tests/tests/headers/ref_argument_array.hpp b/bindgen-tests/tests/headers/ref_argument_array.hpp new file mode 100644 index 0000000000..53f66950d1 --- /dev/null +++ b/bindgen-tests/tests/headers/ref_argument_array.hpp @@ -0,0 +1,6 @@ + +#define NSID_LENGTH 10 +class nsID { +public: + virtual void ToProvidedString(char (&aDest)[NSID_LENGTH]); +}; diff --git a/bindgen-tests/tests/headers/references.hpp b/bindgen-tests/tests/headers/references.hpp new file mode 100644 index 0000000000..6b56823d12 --- /dev/null +++ b/bindgen-tests/tests/headers/references.hpp @@ -0,0 +1,17 @@ +// bindgen-flags: --nonnull-references + +struct Container { + int *normalPointer; + const int *constPointer; + int &normalRef; + const int &constRef; + int *&pointerRef; + const int *&constPointerRef; +}; + +int &refReturningFunction(); + +void functionConsumingRef(int &someRef, float normalArgument, + const int &constRef); + +void functionConsumingPointerRef(int* &pointerRef); diff --git a/bindgen-tests/tests/headers/reparented_replacement.hpp b/bindgen-tests/tests/headers/reparented_replacement.hpp new file mode 100644 index 0000000000..4ac2bf03c8 --- /dev/null +++ b/bindgen-tests/tests/headers/reparented_replacement.hpp @@ -0,0 +1,16 @@ +// bindgen-flags: --enable-cxx-namespaces + +namespace foo { + struct Bar { + int baz; + }; +} + +namespace bar { + ///
+ struct Bar_Replacement { + int bazz; + }; +}; + +typedef foo::Bar ReferencesBar; diff --git a/bindgen-tests/tests/headers/replace_template_alias.hpp b/bindgen-tests/tests/headers/replace_template_alias.hpp new file mode 100644 index 0000000000..c325b5a38e --- /dev/null +++ b/bindgen-tests/tests/headers/replace_template_alias.hpp @@ -0,0 +1,23 @@ +// bindgen-flags: -- --std=c++14 + +namespace JS { +namespace detail { + +/// Notice how this doesn't use T. +template +using MaybeWrapped = int; + +} + +template +class Rooted { + detail::MaybeWrapped ptr; +}; + +} + +/// But the replacement type does use T! +/// +///
+template +using replaces_MaybeWrapped = T; diff --git a/bindgen-tests/tests/headers/replace_use.hpp b/bindgen-tests/tests/headers/replace_use.hpp new file mode 100644 index 0000000000..de44eb19cc --- /dev/null +++ b/bindgen-tests/tests/headers/replace_use.hpp @@ -0,0 +1,15 @@ +template +struct nsTArray { + int x; +}; +/** + *
+ */ +template +struct nsTArray_Simple { + unsigned int y; +}; + +struct Test { + nsTArray a; +}; diff --git a/tests/headers/replaces_double.hpp b/bindgen-tests/tests/headers/replaces_double.hpp similarity index 85% rename from tests/headers/replaces_double.hpp rename to bindgen-tests/tests/headers/replaces_double.hpp index 1a78b0d92b..ce6a8dbb45 100644 --- a/tests/headers/replaces_double.hpp +++ b/bindgen-tests/tests/headers/replaces_double.hpp @@ -1,4 +1,4 @@ -// bindgen-flags: --blacklist-type Wrapper -- --std=c++11 +// bindgen-flags: --blocklist-type Wrapper -- --std=c++11 template struct Wrapper { diff --git a/bindgen-tests/tests/headers/repr-align.hpp b/bindgen-tests/tests/headers/repr-align.hpp new file mode 100644 index 0000000000..a7719e10ed --- /dev/null +++ b/bindgen-tests/tests/headers/repr-align.hpp @@ -0,0 +1,11 @@ +// bindgen-flags: --raw-line '#![cfg(feature = "nightly")]' -- -std=c++11 + +struct alignas(8) a { + int b; + int c; +}; + +struct alignas(double) b { + int b; + int c; +}; diff --git a/bindgen-tests/tests/headers/resolved_type_def_function.h b/bindgen-tests/tests/headers/resolved_type_def_function.h new file mode 100644 index 0000000000..139b8c3e85 --- /dev/null +++ b/bindgen-tests/tests/headers/resolved_type_def_function.h @@ -0,0 +1,2 @@ +typedef void (FuncType) (); +extern FuncType Func; \ No newline at end of file diff --git a/bindgen-tests/tests/headers/same_struct_name_in_different_namespaces.hpp b/bindgen-tests/tests/headers/same_struct_name_in_different_namespaces.hpp new file mode 100644 index 0000000000..fe6858458f --- /dev/null +++ b/bindgen-tests/tests/headers/same_struct_name_in_different_namespaces.hpp @@ -0,0 +1,12 @@ +namespace JS { + + struct Zone; + + namespace shadow { + + struct Zone { + int x; + int y; + }; + } +} diff --git a/bindgen-tests/tests/headers/sentry-defined-multiple-times.hpp b/bindgen-tests/tests/headers/sentry-defined-multiple-times.hpp new file mode 100644 index 0000000000..d44837d08e --- /dev/null +++ b/bindgen-tests/tests/headers/sentry-defined-multiple-times.hpp @@ -0,0 +1,85 @@ +// bindgen-flags: --enable-cxx-namespaces -- -std=c++11 + +// `Wrapper::sentry` and `sentry` should be emitted as `Wrapper_sentry` and +// `sentry` respectively, but instead `Wrapper::sentry` is named just `sentry` +// which leads to compilation errors. +// +// Note: if there is no namespace, then we don't run into problems. Similarly, +// making the `Wrapper::sentry` definition inline in `Wrapper`, rather than +// declared inline with an out of line definition, makes the problem go away as +// well. + +namespace whatever { + template + class Wrapper { + // Declaration of Wrapper::sentry + class sentry; + }; + + // Definition of Wrapper::sentry + template + class Wrapper::sentry { + int i_am_wrapper_sentry; + }; + + class sentry { + bool i_am_plain_sentry; + }; + + // Ok, that was the original bug report. While we're here, let's just try + // lots of different things that could go wrong and make sure we handle them + // right. + + class NotTemplateWrapper { + class sentry; + }; + + class NotTemplateWrapper::sentry { + char i_am_not_template_wrapper_sentry; + }; + + class InlineNotTemplateWrapper { + class sentry { + bool i_am_inline_not_template_wrapper_sentry; + }; + }; + + template + class InlineTemplateWrapper { + class sentry { + int i_am_inline_template_wrapper_sentry; + }; + }; + + class OuterDoubleWrapper { + class InnerDoubleWrapper { + class sentry; + }; + }; + + class OuterDoubleWrapper::InnerDoubleWrapper::sentry { + int i_am_double_wrapper_sentry; + }; + + class OuterDoubleInlineWrapper { + class InnerDoubleInlineWrapper { + class sentry { + int i_am_double_wrapper_inline_sentry; + }; + }; + }; +} + +template +class OutsideNamespaceWrapper { + class sentry; +}; + +template +class OutsideNamespaceWrapper::sentry { + int i_am_outside_namespace_wrapper_sentry; +}; + +class sentry { + int i_am_outside_namespace_sentry; +}; diff --git a/bindgen-tests/tests/headers/short-enums.hpp b/bindgen-tests/tests/headers/short-enums.hpp new file mode 100644 index 0000000000..14f833de64 --- /dev/null +++ b/bindgen-tests/tests/headers/short-enums.hpp @@ -0,0 +1,19 @@ +// bindgen-flags: --rustified-enum ".*" -- -std=c++11 -fshort-enums + +typedef enum { + SOME_VALUE = 0x1, +} one_byte_t; + +static_assert(sizeof(one_byte_t) == 1, "Short enums should work"); + +typedef enum { + SOME_OTHER_VALUE = 0x100, +} two_byte_t; + +static_assert(sizeof(two_byte_t) == 2, ""); + +typedef enum { + SOME_BIGGER_VALUE = 0x1000000, +} four_byte_t; + +static_assert(sizeof(four_byte_t) == 4, ""); diff --git a/tests/headers/size_t_template.hpp b/bindgen-tests/tests/headers/size_t_template.hpp similarity index 100% rename from tests/headers/size_t_template.hpp rename to bindgen-tests/tests/headers/size_t_template.hpp diff --git a/bindgen-tests/tests/headers/sorted_items.hpp b/bindgen-tests/tests/headers/sorted_items.hpp new file mode 100644 index 0000000000..9b5ced9637 --- /dev/null +++ b/bindgen-tests/tests/headers/sorted_items.hpp @@ -0,0 +1,35 @@ +// bindgen-flags: --sort-semantically --enable-cxx-namespaces -- --target=x86_64-unknown-linux + +int foo(); +typedef int number; +int bar(number x); +struct Point +{ + number x; + number y; +}; +struct Angle +{ + number a; + number b; +}; +int baz(struct Point point); +const number NUMBER = 42; + +namespace ns { + int foo(); + typedef int number; + int bar(number x); + struct Point + { + number x; + number y; + }; + struct Angle + { + number a; + number b; + }; + int baz(struct Point point); + const number NUMBER = 42; +} diff --git a/bindgen-tests/tests/headers/special-members.hpp b/bindgen-tests/tests/headers/special-members.hpp new file mode 100644 index 0000000000..753b2fdc0a --- /dev/null +++ b/bindgen-tests/tests/headers/special-members.hpp @@ -0,0 +1,7 @@ +class A { +public: + A(); + A(A&); + A(A&&); + ~A(); +}; \ No newline at end of file diff --git a/bindgen-tests/tests/headers/specific_receiver.hpp b/bindgen-tests/tests/headers/specific_receiver.hpp new file mode 100644 index 0000000000..a521f9f0b2 --- /dev/null +++ b/bindgen-tests/tests/headers/specific_receiver.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --use-specific-virtual-function-receiver --generate-inline-functions -- -x c++ -std=c++14 + +class Fish { +public: + virtual void swim() { + } +}; diff --git a/bindgen-tests/tests/headers/stdint_typedef.h b/bindgen-tests/tests/headers/stdint_typedef.h new file mode 100644 index 0000000000..f716a7f1a0 --- /dev/null +++ b/bindgen-tests/tests/headers/stdint_typedef.h @@ -0,0 +1,10 @@ +// bindgen-flags: --allowlist-type="Struct" --allowlist-function="fun" + +// no typedef should be emitted for `__uint64_t` +typedef unsigned long long __uint64_t; +typedef __uint64_t uint64_t; + +uint64_t fun(); +struct Struct { + uint64_t field; +}; diff --git a/bindgen-tests/tests/headers/strings_array.h b/bindgen-tests/tests/headers/strings_array.h new file mode 100644 index 0000000000..fa7bf561fa --- /dev/null +++ b/bindgen-tests/tests/headers/strings_array.h @@ -0,0 +1,3 @@ +const char* MY_STRING_UTF8 = "Hello, world!"; +const char* MY_STRING_INTERIOR_NULL = "Hello,\0World!"; +const char* MY_STRING_NON_UTF8 = "ABCDE\xFF"; diff --git a/bindgen-tests/tests/headers/strings_cstr.h b/bindgen-tests/tests/headers/strings_cstr.h new file mode 100644 index 0000000000..8b1d40e689 --- /dev/null +++ b/bindgen-tests/tests/headers/strings_cstr.h @@ -0,0 +1,5 @@ +// bindgen-flags: --rust-target=1.59 --generate-cstr + +const char* MY_STRING_UTF8 = "Hello, world!"; +const char* MY_STRING_INTERIOR_NULL = "Hello,\0World!"; +const char* MY_STRING_NON_UTF8 = "ABCDE\xFF"; diff --git a/bindgen-tests/tests/headers/strings_cstr2.h b/bindgen-tests/tests/headers/strings_cstr2.h new file mode 100644 index 0000000000..2cd7e6222d --- /dev/null +++ b/bindgen-tests/tests/headers/strings_cstr2.h @@ -0,0 +1,5 @@ +// bindgen-flags: --rust-target=1.77 --generate-cstr + +const char* MY_STRING_UTF8 = "Hello, world!"; +const char* MY_STRING_INTERIOR_NULL = "Hello,\0World!"; +const char* MY_STRING_NON_UTF8 = "ABCDE\xFF"; diff --git a/bindgen-tests/tests/headers/strings_cstr2_2018.h b/bindgen-tests/tests/headers/strings_cstr2_2018.h new file mode 100644 index 0000000000..67d117a1bc --- /dev/null +++ b/bindgen-tests/tests/headers/strings_cstr2_2018.h @@ -0,0 +1,5 @@ +// bindgen-flags: --rust-target=1.77 --rust-edition=2018 --generate-cstr + +const char* MY_STRING_UTF8 = "Hello, world!"; +const char* MY_STRING_INTERIOR_NULL = "Hello,\0World!"; +const char* MY_STRING_NON_UTF8 = "ABCDE\xFF"; diff --git a/bindgen-tests/tests/headers/struct_containing_forward_declared_struct.h b/bindgen-tests/tests/headers/struct_containing_forward_declared_struct.h new file mode 100644 index 0000000000..cf7cb5c40c --- /dev/null +++ b/bindgen-tests/tests/headers/struct_containing_forward_declared_struct.h @@ -0,0 +1,8 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +struct a { + struct b* val_a; +}; + +struct b { + int val_b; +}; diff --git a/bindgen-tests/tests/headers/struct_typedef.h b/bindgen-tests/tests/headers/struct_typedef.h new file mode 100644 index 0000000000..2ed7aabd94 --- /dev/null +++ b/bindgen-tests/tests/headers/struct_typedef.h @@ -0,0 +1,17 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*" +// +typedef struct { + _Bool has_name; +} typedef_named_struct; + +typedef struct { + void *no_name; +} *struct_ptr_t, **struct_ptr_ptr_t; + +typedef enum { + ENUM_HAS_NAME=1 +} typedef_named_enum; + +typedef enum { + ENUM_IS_ANON +} *enum_ptr_t, **enum_ptr_ptr_t; diff --git a/bindgen-tests/tests/headers/struct_typedef_ns.hpp b/bindgen-tests/tests/headers/struct_typedef_ns.hpp new file mode 100644 index 0000000000..40a7c680a2 --- /dev/null +++ b/bindgen-tests/tests/headers/struct_typedef_ns.hpp @@ -0,0 +1,21 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --enable-cxx-namespaces --rustified-enum ".*" + +namespace whatever { + typedef struct { + int foo; + } typedef_struct; + + typedef enum { + BAR=1 + } typedef_enum; +} + +namespace { + typedef struct { + int foo; + } typedef_struct; + + typedef enum { + BAR=1 + } typedef_enum; +} diff --git a/bindgen-tests/tests/headers/struct_with_anon_struct.h b/bindgen-tests/tests/headers/struct_with_anon_struct.h new file mode 100644 index 0000000000..a5e8476d3c --- /dev/null +++ b/bindgen-tests/tests/headers/struct_with_anon_struct.h @@ -0,0 +1,8 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +struct foo { + struct { + int a; + int b; + } bar; +}; diff --git a/bindgen-tests/tests/headers/struct_with_anon_struct_array.h b/bindgen-tests/tests/headers/struct_with_anon_struct_array.h new file mode 100644 index 0000000000..94a8ea0a62 --- /dev/null +++ b/bindgen-tests/tests/headers/struct_with_anon_struct_array.h @@ -0,0 +1,12 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +struct foo { + struct { + int a; + int b; + } bar[2]; + struct { + int a; + int b; + } baz[2][3][4]; +}; diff --git a/bindgen-tests/tests/headers/struct_with_anon_struct_pointer.h b/bindgen-tests/tests/headers/struct_with_anon_struct_pointer.h new file mode 100644 index 0000000000..d92c801102 --- /dev/null +++ b/bindgen-tests/tests/headers/struct_with_anon_struct_pointer.h @@ -0,0 +1,7 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +struct foo { + struct { + int a; + int b; + } *bar; +}; diff --git a/bindgen-tests/tests/headers/struct_with_anon_union.h b/bindgen-tests/tests/headers/struct_with_anon_union.h new file mode 100644 index 0000000000..bd75563d35 --- /dev/null +++ b/bindgen-tests/tests/headers/struct_with_anon_union.h @@ -0,0 +1,8 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +struct foo { + union { + unsigned int a; + unsigned short b; + } bar; +}; diff --git a/bindgen-tests/tests/headers/struct_with_anon_unnamed_struct.h b/bindgen-tests/tests/headers/struct_with_anon_unnamed_struct.h new file mode 100644 index 0000000000..92705238d6 --- /dev/null +++ b/bindgen-tests/tests/headers/struct_with_anon_unnamed_struct.h @@ -0,0 +1,7 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +struct foo { + struct { + unsigned int a; + unsigned int b; + }; +}; diff --git a/bindgen-tests/tests/headers/struct_with_anon_unnamed_union.h b/bindgen-tests/tests/headers/struct_with_anon_unnamed_union.h new file mode 100644 index 0000000000..00fa4900c1 --- /dev/null +++ b/bindgen-tests/tests/headers/struct_with_anon_unnamed_union.h @@ -0,0 +1,7 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +struct foo { + union { + unsigned int a; + unsigned short b; + }; +}; diff --git a/bindgen-tests/tests/headers/struct_with_bitfields.h b/bindgen-tests/tests/headers/struct_with_bitfields.h new file mode 100644 index 0000000000..ba1af26d72 --- /dev/null +++ b/bindgen-tests/tests/headers/struct_with_bitfields.h @@ -0,0 +1,14 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +struct bitfield { + unsigned short + a :1, + b :1, + c :1, + :1, + :2, + d :2; + int e; + unsigned int f : 2; + unsigned int g : 32; +}; diff --git a/bindgen-tests/tests/headers/struct_with_derive_debug.h b/bindgen-tests/tests/headers/struct_with_derive_debug.h new file mode 100644 index 0000000000..201748d9c5 --- /dev/null +++ b/bindgen-tests/tests/headers/struct_with_derive_debug.h @@ -0,0 +1,17 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +struct LittleArray { + int a[32]; +}; + +struct BigArray{ + int a[33]; +}; + +struct WithLittleArray { + struct LittleArray a; +}; + +struct WithBigArray { + struct BigArray a; +}; diff --git a/bindgen-tests/tests/headers/struct_with_large_array.hpp b/bindgen-tests/tests/headers/struct_with_large_array.hpp new file mode 100644 index 0000000000..58e8e4d19a --- /dev/null +++ b/bindgen-tests/tests/headers/struct_with_large_array.hpp @@ -0,0 +1,9 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +struct S { + char large_array[33]; +}; + +template struct ST { + T large_array[33]; +}; diff --git a/tests/headers/struct_with_nesting.h b/bindgen-tests/tests/headers/struct_with_nesting.h similarity index 79% rename from tests/headers/struct_with_nesting.h rename to bindgen-tests/tests/headers/struct_with_nesting.h index 9d7fa17627..ac902b443e 100644 --- a/tests/headers/struct_with_nesting.h +++ b/bindgen-tests/tests/headers/struct_with_nesting.h @@ -1,3 +1,5 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// struct foo { unsigned int a; union { diff --git a/bindgen-tests/tests/headers/struct_with_packing.h b/bindgen-tests/tests/headers/struct_with_packing.h new file mode 100644 index 0000000000..9ed5031759 --- /dev/null +++ b/bindgen-tests/tests/headers/struct_with_packing.h @@ -0,0 +1,6 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +struct a { + char b; + short c; +} __attribute__((packed)); diff --git a/bindgen-tests/tests/headers/struct_with_struct.h b/bindgen-tests/tests/headers/struct_with_struct.h new file mode 100644 index 0000000000..1a17807465 --- /dev/null +++ b/bindgen-tests/tests/headers/struct_with_struct.h @@ -0,0 +1,8 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +struct foo { + struct { + unsigned int x; + unsigned int y; + } bar; +}; diff --git a/bindgen-tests/tests/headers/struct_with_typedef_template_arg.hpp b/bindgen-tests/tests/headers/struct_with_typedef_template_arg.hpp new file mode 100644 index 0000000000..ec1b55aa4b --- /dev/null +++ b/bindgen-tests/tests/headers/struct_with_typedef_template_arg.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +template +struct Proxy { + typedef void (*foo)(T* bar); +}; diff --git a/bindgen-tests/tests/headers/template-fun-ty.hpp b/bindgen-tests/tests/headers/template-fun-ty.hpp new file mode 100644 index 0000000000..bb9d23cf13 --- /dev/null +++ b/bindgen-tests/tests/headers/template-fun-ty.hpp @@ -0,0 +1,17 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +template +class Foo +{ + typedef T (FunctionPtr)(); +}; + +template +class RefPtr { + template + class Proxy { + typedef R (T::*member_function)(Args...); + }; +}; + +template +using Returner = T(*)(); diff --git a/bindgen-tests/tests/headers/template-param-usage-0.hpp b/bindgen-tests/tests/headers/template-param-usage-0.hpp new file mode 100644 index 0000000000..57c11a105e --- /dev/null +++ b/bindgen-tests/tests/headers/template-param-usage-0.hpp @@ -0,0 +1,6 @@ +// bindgen-flags: -- -std=c++14 + +template +class UsesTemplateParameter { + T t; +}; diff --git a/bindgen-tests/tests/headers/template-param-usage-1.hpp b/bindgen-tests/tests/headers/template-param-usage-1.hpp new file mode 100644 index 0000000000..dba41489d8 --- /dev/null +++ b/bindgen-tests/tests/headers/template-param-usage-1.hpp @@ -0,0 +1,6 @@ +// bindgen-flags: -- -std=c++14 + +template +class DoesNotUseTemplateParameter { + int x; +}; diff --git a/bindgen-tests/tests/headers/template-param-usage-10.hpp b/bindgen-tests/tests/headers/template-param-usage-10.hpp new file mode 100644 index 0000000000..a6f3ccd871 --- /dev/null +++ b/bindgen-tests/tests/headers/template-param-usage-10.hpp @@ -0,0 +1,14 @@ +// bindgen-flags: -- -std=c++14 + +template +class DoublyIndirectUsage { + using Aliased = T; + typedef U Typedefed; + + class IndirectUsage { + Aliased member; + Typedefed another; + }; + + IndirectUsage doubly_indirect; +}; diff --git a/bindgen-tests/tests/headers/template-param-usage-11.hpp b/bindgen-tests/tests/headers/template-param-usage-11.hpp new file mode 100644 index 0000000000..8780f5d357 --- /dev/null +++ b/bindgen-tests/tests/headers/template-param-usage-11.hpp @@ -0,0 +1,6 @@ +// bindgen-flags: -- -std=c++14 + +template +class DoesNotUseT { + static T but_static_member_does; +}; diff --git a/bindgen-tests/tests/headers/template-param-usage-12.hpp b/bindgen-tests/tests/headers/template-param-usage-12.hpp new file mode 100644 index 0000000000..9b4cea1988 --- /dev/null +++ b/bindgen-tests/tests/headers/template-param-usage-12.hpp @@ -0,0 +1,11 @@ +// bindgen-flags: -- -std=c++14 + +template +class BaseUsesT { + T* t; +}; + +template +class CrtpUsesU : public BaseUsesT> { + U usage; +}; diff --git a/bindgen-tests/tests/headers/template-param-usage-13.hpp b/bindgen-tests/tests/headers/template-param-usage-13.hpp new file mode 100644 index 0000000000..87db1a10e1 --- /dev/null +++ b/bindgen-tests/tests/headers/template-param-usage-13.hpp @@ -0,0 +1,11 @@ +// bindgen-flags: -- -std=c++14 + +template +class BaseIgnoresT { + int x; +}; + +template +class CrtpUsesU : public BaseIgnoresT> { + U usage; +}; diff --git a/bindgen-tests/tests/headers/template-param-usage-14.hpp b/bindgen-tests/tests/headers/template-param-usage-14.hpp new file mode 100644 index 0000000000..1901629656 --- /dev/null +++ b/bindgen-tests/tests/headers/template-param-usage-14.hpp @@ -0,0 +1,11 @@ +// bindgen-flags: -- -std=c++14 + +template +class BaseIgnoresT { + int x; +}; + +template +class CrtpIgnoresU : public BaseIgnoresT> { + int y; +}; diff --git a/bindgen-tests/tests/headers/template-param-usage-15.hpp b/bindgen-tests/tests/headers/template-param-usage-15.hpp new file mode 100644 index 0000000000..bac7ada77b --- /dev/null +++ b/bindgen-tests/tests/headers/template-param-usage-15.hpp @@ -0,0 +1,11 @@ +// bindgen-flags: -- -std=c++14 + +template +class BaseUsesT { + T* usage; +}; + +template +class CrtpIgnoresU : public BaseUsesT> { + int y; +}; diff --git a/bindgen-tests/tests/headers/template-param-usage-2.hpp b/bindgen-tests/tests/headers/template-param-usage-2.hpp new file mode 100644 index 0000000000..302140ab95 --- /dev/null +++ b/bindgen-tests/tests/headers/template-param-usage-2.hpp @@ -0,0 +1,10 @@ +// bindgen-flags: -- -std=c++14 + +template +class UsesTemplateParameter { + T t; + + class AlsoUsesTemplateParameter { + T also; + }; +}; diff --git a/bindgen-tests/tests/headers/template-param-usage-3.hpp b/bindgen-tests/tests/headers/template-param-usage-3.hpp new file mode 100644 index 0000000000..57396a8a7f --- /dev/null +++ b/bindgen-tests/tests/headers/template-param-usage-3.hpp @@ -0,0 +1,12 @@ +// bindgen-flags: -- -std=c++14 + +template +class UsesTemplateParameter { + T t; + + template + class AlsoUsesTemplateParameterAndMore { + T also; + U more; + }; +}; diff --git a/bindgen-tests/tests/headers/template-param-usage-4.hpp b/bindgen-tests/tests/headers/template-param-usage-4.hpp new file mode 100644 index 0000000000..0415d69210 --- /dev/null +++ b/bindgen-tests/tests/headers/template-param-usage-4.hpp @@ -0,0 +1,11 @@ +// bindgen-flags: -- -std=c++14 + +template +class UsesTemplateParameter { + T t; + + template + class DoesNotUseTemplateParameters { + int x; + }; +}; diff --git a/bindgen-tests/tests/headers/template-param-usage-5.hpp b/bindgen-tests/tests/headers/template-param-usage-5.hpp new file mode 100644 index 0000000000..04b9bf80b7 --- /dev/null +++ b/bindgen-tests/tests/headers/template-param-usage-5.hpp @@ -0,0 +1,8 @@ +// bindgen-flags: -- -std=c++14 + +template +class IndirectlyUsesTemplateParameter { + using Aliased = T; + + Aliased aliased; +}; diff --git a/bindgen-tests/tests/headers/template-param-usage-6.hpp b/bindgen-tests/tests/headers/template-param-usage-6.hpp new file mode 100644 index 0000000000..ee0519c515 --- /dev/null +++ b/bindgen-tests/tests/headers/template-param-usage-6.hpp @@ -0,0 +1,8 @@ +// bindgen-flags: -- -std=c++14 + +template +class DoesNotUseTemplateParameter { + using ButAliasDoesUseIt = T; + + int x; +}; diff --git a/bindgen-tests/tests/headers/template-param-usage-7.hpp b/bindgen-tests/tests/headers/template-param-usage-7.hpp new file mode 100644 index 0000000000..3d70cee145 --- /dev/null +++ b/bindgen-tests/tests/headers/template-param-usage-7.hpp @@ -0,0 +1,10 @@ +// bindgen-flags: -- -std=c++14 + +template +class DoesNotUseU { + T t; + V v; +}; + +// The bool should go away because U is not used. +using Alias = DoesNotUseU; diff --git a/bindgen-tests/tests/headers/template-param-usage-8.hpp b/bindgen-tests/tests/headers/template-param-usage-8.hpp new file mode 100644 index 0000000000..96eabc0649 --- /dev/null +++ b/bindgen-tests/tests/headers/template-param-usage-8.hpp @@ -0,0 +1,10 @@ +// bindgen-flags: -- -std=c++14 + +template +class IndirectUsage { + typedef T Typedefed; + using Aliased = U; + + Typedefed member1; + Aliased member2; +}; diff --git a/bindgen-tests/tests/headers/template-param-usage-9.hpp b/bindgen-tests/tests/headers/template-param-usage-9.hpp new file mode 100644 index 0000000000..b9bd202ca8 --- /dev/null +++ b/bindgen-tests/tests/headers/template-param-usage-9.hpp @@ -0,0 +1,12 @@ +// bindgen-flags: -- -std=c++14 + +template +class DoesNotUse { + using Aliased = T; + typedef U Typedefed; + + class IndirectUsage { + Aliased member; + Typedefed another; + }; +}; diff --git a/bindgen-tests/tests/headers/template-with-var.hpp b/bindgen-tests/tests/headers/template-with-var.hpp new file mode 100644 index 0000000000..88f60d211e --- /dev/null +++ b/bindgen-tests/tests/headers/template-with-var.hpp @@ -0,0 +1,7 @@ +template +class TemplateWithVar { + // We shouldn't generate bindings for this because there are potentially + // many instantiations of this variable, but we can't know which ones exist + // or don't. + static T var = 0; +}; diff --git a/tests/headers/template.hpp b/bindgen-tests/tests/headers/template.hpp similarity index 77% rename from tests/headers/template.hpp rename to bindgen-tests/tests/headers/template.hpp index c13643c398..bc32a357e8 100644 --- a/tests/headers/template.hpp +++ b/bindgen-tests/tests/headers/template.hpp @@ -1,11 +1,40 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++11 +// template class Foo { T m_member; T* m_member_ptr; T m_member_arr[1]; }; +template class B { + T m_member { 0 }; +}; + void bar(Foo foo); +namespace mozilla { +class Foo; +}; + +struct C { + B mB; + B mBConstPtr; + B mBConstStructPtr; + B mBConstStructPtrArray; + B mBConst; + B mBVolatile; + B mBConstBool; + B mBConstChar; + B mBArray; + B mBPtrArray; + B mBArrayPtr; + B mBRef; + B mBConstRef; + B mPtrRef; + B mArrayRef; + B mBConstArray; +}; + template class D { typedef Foo MyFoo; @@ -137,8 +166,3 @@ class ReplacedWithDestructorDeclaredAfter { T* buff; ~ReplacedWithDestructorDeclaredAfter() {}; }; - -template -class TemplateWithVar { - static T var = 0; -}; diff --git a/bindgen-tests/tests/headers/template_alias.hpp b/bindgen-tests/tests/headers/template_alias.hpp new file mode 100644 index 0000000000..8b3ea692ef --- /dev/null +++ b/bindgen-tests/tests/headers/template_alias.hpp @@ -0,0 +1,13 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++14 + +namespace JS { +namespace detail { + template + using Wrapped = T; +} + +template +struct Rooted { + detail::Wrapped ptr; +}; +} diff --git a/tests/headers/template_alias_basic.hpp b/bindgen-tests/tests/headers/template_alias_basic.hpp similarity index 100% rename from tests/headers/template_alias_basic.hpp rename to bindgen-tests/tests/headers/template_alias_basic.hpp diff --git a/bindgen-tests/tests/headers/template_alias_namespace.hpp b/bindgen-tests/tests/headers/template_alias_namespace.hpp new file mode 100644 index 0000000000..c20bf2069b --- /dev/null +++ b/bindgen-tests/tests/headers/template_alias_namespace.hpp @@ -0,0 +1,13 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --enable-cxx-namespaces -- -std=c++14 + +namespace JS { +namespace detail { + template + using Wrapped = T; +} + +template +struct Rooted { + detail::Wrapped ptr; +}; +} diff --git a/bindgen-tests/tests/headers/template_fun.hpp b/bindgen-tests/tests/headers/template_fun.hpp new file mode 100644 index 0000000000..17b1383bcf --- /dev/null +++ b/bindgen-tests/tests/headers/template_fun.hpp @@ -0,0 +1,3 @@ +// this will be ignored +template +void foo() {} diff --git a/bindgen-tests/tests/headers/template_instantiation_with_fn_local_type.hpp b/bindgen-tests/tests/headers/template_instantiation_with_fn_local_type.hpp new file mode 100644 index 0000000000..b7ff28b099 --- /dev/null +++ b/bindgen-tests/tests/headers/template_instantiation_with_fn_local_type.hpp @@ -0,0 +1,27 @@ +// bindgen-flags: -- -std=c++14 +// +// https://github.com/rust-lang/rust-bindgen/issues/2036 + +template +struct Foo {}; +template +Foo foo{}; + +// Struct inside function +void f() { + struct Bar { + Bar() {} + }; + foo; +} + +// Struct inside method +class Baz { + void f() { + struct Boo { + Boo() {} + }; + foo; + } +}; + diff --git a/bindgen-tests/tests/headers/template_partial_specification.hpp b/bindgen-tests/tests/headers/template_partial_specification.hpp new file mode 100644 index 0000000000..fe1be65868 --- /dev/null +++ b/bindgen-tests/tests/headers/template_partial_specification.hpp @@ -0,0 +1,10 @@ +// bindgen-flags: -- --target=x86_64-pc-win32 + +template +struct nsRunnableMethodTraits; + +template +struct nsRunnableMethodTraits +{ + static const bool can_cancel = Cancelable; +}; diff --git a/bindgen-tests/tests/headers/template_typedef_transitive_param.hpp b/bindgen-tests/tests/headers/template_typedef_transitive_param.hpp new file mode 100644 index 0000000000..34a5b92c25 --- /dev/null +++ b/bindgen-tests/tests/headers/template_typedef_transitive_param.hpp @@ -0,0 +1,8 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +template +struct Wrapper { + struct Wrapped { + T t; + }; + using Type = Wrapped; +}; diff --git a/tests/headers/template_typedefs.hpp b/bindgen-tests/tests/headers/template_typedefs.hpp similarity index 100% rename from tests/headers/template_typedefs.hpp rename to bindgen-tests/tests/headers/template_typedefs.hpp diff --git a/bindgen-tests/tests/headers/templateref_opaque.hpp b/bindgen-tests/tests/headers/templateref_opaque.hpp new file mode 100644 index 0000000000..2f6a002718 --- /dev/null +++ b/bindgen-tests/tests/headers/templateref_opaque.hpp @@ -0,0 +1,12 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq + +namespace detail { +template +struct PointerType { + typedef T* Type; +}; +} +template +class UniquePtr { + typedef typename detail::PointerType Pointer; +}; diff --git a/bindgen-tests/tests/headers/templatized-bitfield.hpp b/bindgen-tests/tests/headers/templatized-bitfield.hpp new file mode 100644 index 0000000000..ed4a154058 --- /dev/null +++ b/bindgen-tests/tests/headers/templatized-bitfield.hpp @@ -0,0 +1,7 @@ +/// We don't get a layout for this bitfield, since we don't know what `T` will +/// be, so we cannot allocate bitfield units. The best thing we can do is make +/// the struct opaque. +template +class TemplatizedBitfield { + T t : 6; +}; diff --git a/bindgen-tests/tests/headers/timex.h b/bindgen-tests/tests/headers/timex.h new file mode 100644 index 0000000000..1add26cabe --- /dev/null +++ b/bindgen-tests/tests/headers/timex.h @@ -0,0 +1,15 @@ +struct timex { + int tai; + + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; +}; + +struct timex_named { + int tai; + + int a:32; int b:32; int c:32; int d:32; + int e:32; int f:32; int g:32; int h:32; + int i:32; int j:32; int k:32; +}; diff --git a/bindgen-tests/tests/headers/transform-op.hpp b/bindgen-tests/tests/headers/transform-op.hpp new file mode 100644 index 0000000000..090e88b34b --- /dev/null +++ b/bindgen-tests/tests/headers/transform-op.hpp @@ -0,0 +1,75 @@ +// bindgen-flags: -- -std=c++11 + +typedef unsigned char uint8_t; +typedef int int32_t; + +template +struct StylePoint { + T x; + T y; +}; + +template +union StyleFoo { + enum class Tag : uint8_t { + Foo, + Bar, + Baz, + Bazz, + }; + + struct Foo_Body { + Tag tag; + int32_t x; + StylePoint y; + StylePoint z; + }; + + struct Bar_Body { + Tag tag; + T _0; + }; + + struct Baz_Body { + Tag tag; + StylePoint _0; + }; + + struct { + Tag tag; + }; + Foo_Body foo; + Bar_Body bar; + Baz_Body baz; +}; + +template +struct StyleBar { + enum class Tag { + Bar1, + Bar2, + Bar3, + Bar4, + }; + + struct StyleBar1_Body { + int32_t x; + StylePoint y; + StylePoint z; + }; + + struct StyleBar2_Body { + T _0; + }; + + struct StyleBar3_Body { + StylePoint _0; + }; + + Tag tag; + union { + StyleBar1_Body bar1; + StyleBar2_Body bar2; + StyleBar3_Body bar3; + }; +}; diff --git a/bindgen-tests/tests/headers/type-referenced-by-allowlisted-function.h b/bindgen-tests/tests/headers/type-referenced-by-allowlisted-function.h new file mode 100644 index 0000000000..bf675bc9a7 --- /dev/null +++ b/bindgen-tests/tests/headers/type-referenced-by-allowlisted-function.h @@ -0,0 +1,7 @@ +// bindgen-flags: --allowlist-function dl_iterate_phdr + +struct dl_phdr_info { + int x; +}; + +int dl_iterate_phdr(struct dl_phdr_info *); diff --git a/bindgen-tests/tests/headers/type_alias_empty.hpp b/bindgen-tests/tests/headers/type_alias_empty.hpp new file mode 100644 index 0000000000..bcccc3c85e --- /dev/null +++ b/bindgen-tests/tests/headers/type_alias_empty.hpp @@ -0,0 +1,10 @@ +// bindgen-flags: --allowlist-type bool_constant -- -std=c++11 + +// NB: The --allowlist-type is done to trigger the traversal of the types on +// codegen in order to trigger #67. + +template +struct integral_constant {}; + +template +using bool_constant = integral_constant; diff --git a/bindgen-tests/tests/headers/type_alias_partial_template_especialization.hpp b/bindgen-tests/tests/headers/type_alias_partial_template_especialization.hpp new file mode 100644 index 0000000000..dfc36786c4 --- /dev/null +++ b/bindgen-tests/tests/headers/type_alias_partial_template_especialization.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: -- -std=c++14 +template using MaybeWrapped = A; + +template +class Rooted { + MaybeWrapped ptr; +}; diff --git a/bindgen-tests/tests/headers/type_alias_template_specialized.hpp b/bindgen-tests/tests/headers/type_alias_template_specialized.hpp new file mode 100644 index 0000000000..f7403a36d0 --- /dev/null +++ b/bindgen-tests/tests/headers/type_alias_template_specialized.hpp @@ -0,0 +1,9 @@ +// bindgen-flags: --allowlist-type Rooted -- -std=c++14 + +template using MaybeWrapped = a; +class Rooted { + MaybeWrapped ptr; +}; + +///
+template using replaces_MaybeWrapped = a; diff --git a/bindgen-tests/tests/headers/typedef-pointer-overlap.h b/bindgen-tests/tests/headers/typedef-pointer-overlap.h new file mode 100644 index 0000000000..8c556c9b38 --- /dev/null +++ b/bindgen-tests/tests/headers/typedef-pointer-overlap.h @@ -0,0 +1,30 @@ +typedef const struct foo { + char inner; +} *foo; + +typedef struct bar { + char inner; +} *bar; + +typedef struct baz *baz; + +typedef union cat { + int standard_issue; +} *cat; + +typedef enum mad { scientist } *mad; + +void takes_foo_ptr(foo); +void takes_foo_struct(struct foo); + +void takes_bar_ptr(bar); +void takes_bar_struct(struct bar); + +void takes_baz_ptr(baz); +void takes_baz_struct(struct baz); + +void takes_cat_ptr(cat); +void takes_cat_union(union cat); + +void takes_mad_ptr(mad); +void takes_mad_enum(enum mad); diff --git a/bindgen-tests/tests/headers/typedefd-array-as-function-arg.h b/bindgen-tests/tests/headers/typedefd-array-as-function-arg.h new file mode 100644 index 0000000000..937905918c --- /dev/null +++ b/bindgen-tests/tests/headers/typedefd-array-as-function-arg.h @@ -0,0 +1,3 @@ +// foo.h +typedef float myVector3[3]; +void modifyVectorFunc(myVector3 v); diff --git a/tests/headers/typeref.hpp b/bindgen-tests/tests/headers/typeref.hpp similarity index 83% rename from tests/headers/typeref.hpp rename to bindgen-tests/tests/headers/typeref.hpp index b94c98ef6b..bdc1b30281 100644 --- a/tests/headers/typeref.hpp +++ b/bindgen-tests/tests/headers/typeref.hpp @@ -1,3 +1,4 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq struct nsFoo; namespace mozilla { diff --git a/bindgen-tests/tests/headers/uncallable_functions.hpp b/bindgen-tests/tests/headers/uncallable_functions.hpp new file mode 100644 index 0000000000..9187470c65 --- /dev/null +++ b/bindgen-tests/tests/headers/uncallable_functions.hpp @@ -0,0 +1,9 @@ +// bindgen-flags: --generate-deleted-functions --generate-private-functions --generate-pure-virtual-functions --generate-inline-functions -- -x c++ -std=c++14 + +class Test { +public: + virtual void a() = 0; + void b() = delete; +private: + void c() {} +}; diff --git a/bindgen-tests/tests/headers/underscore.hpp b/bindgen-tests/tests/headers/underscore.hpp new file mode 100644 index 0000000000..1c9371f123 --- /dev/null +++ b/bindgen-tests/tests/headers/underscore.hpp @@ -0,0 +1,3 @@ +const int _ = 10; + +typedef struct { unsigned char _[8]; } ptr_t; \ No newline at end of file diff --git a/bindgen-tests/tests/headers/union-align.h b/bindgen-tests/tests/headers/union-align.h new file mode 100644 index 0000000000..5ed955f25e --- /dev/null +++ b/bindgen-tests/tests/headers/union-align.h @@ -0,0 +1,8 @@ +union Bar { + unsigned char foo; +} __attribute__ ((__aligned__ (16))); + + +union Baz { + union Bar bar; +}; diff --git a/bindgen-tests/tests/headers/union-in-ns.hpp b/bindgen-tests/tests/headers/union-in-ns.hpp new file mode 100644 index 0000000000..68b8f72d6e --- /dev/null +++ b/bindgen-tests/tests/headers/union-in-ns.hpp @@ -0,0 +1,5 @@ +// bindgen-flags: --enable-cxx-namespaces + +union bar { + int baz; +}; diff --git a/bindgen-tests/tests/headers/union_bitfield.h b/bindgen-tests/tests/headers/union_bitfield.h new file mode 100644 index 0000000000..4592a8973a --- /dev/null +++ b/bindgen-tests/tests/headers/union_bitfield.h @@ -0,0 +1,10 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --impl-partialeq + +union U4 { + unsigned int derp:1; /* 0: 0 4 */ +}; + +union B { + unsigned int foo:31; /* 0: 0 4 */ + unsigned char bar:1; /* 0: 0 1 */ +}; diff --git a/tests/headers/union_dtor.hpp b/bindgen-tests/tests/headers/union_dtor.hpp similarity index 100% rename from tests/headers/union_dtor.hpp rename to bindgen-tests/tests/headers/union_dtor.hpp diff --git a/bindgen-tests/tests/headers/union_fields.hpp b/bindgen-tests/tests/headers/union_fields.hpp new file mode 100644 index 0000000000..7bb2a3ce3b --- /dev/null +++ b/bindgen-tests/tests/headers/union_fields.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +typedef union { + int mInt; + float mFloat; + void* mPointer; +} nsStyleUnion; diff --git a/bindgen-tests/tests/headers/union_template.hpp b/bindgen-tests/tests/headers/union_template.hpp new file mode 100644 index 0000000000..8b57f5a0e7 --- /dev/null +++ b/bindgen-tests/tests/headers/union_template.hpp @@ -0,0 +1,21 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +template +struct NastyStruct { + bool mIsSome; + union { + void* mFoo; + unsigned long mDummy; + } mStorage; + + union { + short wat; + int* wut; + }; +}; + +template +union Whatever { + void* mTPtr; + int mInt; +}; diff --git a/bindgen-tests/tests/headers/union_with_anon_struct.h b/bindgen-tests/tests/headers/union_with_anon_struct.h new file mode 100644 index 0000000000..b239b2d87a --- /dev/null +++ b/bindgen-tests/tests/headers/union_with_anon_struct.h @@ -0,0 +1,8 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +union foo { + struct { + unsigned int a; + unsigned int b; + } bar; +}; diff --git a/bindgen-tests/tests/headers/union_with_anon_struct_bitfield.h b/bindgen-tests/tests/headers/union_with_anon_struct_bitfield.h new file mode 100644 index 0000000000..bbb1ef4189 --- /dev/null +++ b/bindgen-tests/tests/headers/union_with_anon_struct_bitfield.h @@ -0,0 +1,9 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +union foo { + int a; + struct { + int b : 7; + int c : 25; + }; +}; diff --git a/bindgen-tests/tests/headers/union_with_anon_union.h b/bindgen-tests/tests/headers/union_with_anon_union.h new file mode 100644 index 0000000000..02b09e2e02 --- /dev/null +++ b/bindgen-tests/tests/headers/union_with_anon_union.h @@ -0,0 +1,8 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +union foo { + union { + unsigned int a; + unsigned short b; + } bar; +}; diff --git a/bindgen-tests/tests/headers/union_with_anon_unnamed_struct.h b/bindgen-tests/tests/headers/union_with_anon_unnamed_struct.h new file mode 100644 index 0000000000..0490331889 --- /dev/null +++ b/bindgen-tests/tests/headers/union_with_anon_unnamed_struct.h @@ -0,0 +1,11 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +union pixel { + unsigned int rgba; + struct { + unsigned char r; + unsigned char g; + unsigned char b; + unsigned char a; + }; +}; diff --git a/bindgen-tests/tests/headers/union_with_anon_unnamed_union.h b/bindgen-tests/tests/headers/union_with_anon_unnamed_union.h new file mode 100644 index 0000000000..dbccd5b52f --- /dev/null +++ b/bindgen-tests/tests/headers/union_with_anon_unnamed_union.h @@ -0,0 +1,9 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +union foo { + unsigned int a; + union { + unsigned short b; + unsigned char c; + }; +}; diff --git a/bindgen-tests/tests/headers/union_with_big_member.h b/bindgen-tests/tests/headers/union_with_big_member.h new file mode 100644 index 0000000000..e8a3fe0a9c --- /dev/null +++ b/bindgen-tests/tests/headers/union_with_big_member.h @@ -0,0 +1,16 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +union WithBigArray { + int a; + int b[33]; +}; + +union WithBigArray2 { + int a; + char b[33]; +}; + +union WithBigMember { + int a; + union WithBigArray b; +}; diff --git a/bindgen-tests/tests/headers/union_with_nesting.h b/bindgen-tests/tests/headers/union_with_nesting.h new file mode 100644 index 0000000000..ae25244a04 --- /dev/null +++ b/bindgen-tests/tests/headers/union_with_nesting.h @@ -0,0 +1,16 @@ +// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq +// +union foo { + unsigned int a; + struct { + union { + unsigned short b1; + unsigned short b2; + }; + + union { + unsigned short c1; + unsigned short c2; + }; + }; +}; diff --git a/bindgen-tests/tests/headers/union_with_non_copy_member.h b/bindgen-tests/tests/headers/union_with_non_copy_member.h new file mode 100644 index 0000000000..764820a46d --- /dev/null +++ b/bindgen-tests/tests/headers/union_with_non_copy_member.h @@ -0,0 +1,20 @@ +// bindgen-flags: --bindgen-wrapper-union 'WithBindgenGeneratedWrapper' --manually-drop-union 'WithManuallyDrop' --no-copy 'NonCopyType' + +struct NonCopyType { + int foo; +}; + +union WithBindgenGeneratedWrapper { + struct NonCopyType non_copy_type; + int bar; +}; + +union WithManuallyDrop { + struct NonCopyType non_copy_type; + int bar; +}; + +union WithDefaultWrapper { + struct NonCopyType non_copy_type; + int bar; +}; diff --git a/bindgen-tests/tests/headers/union_with_zero_sized_array.h b/bindgen-tests/tests/headers/union_with_zero_sized_array.h new file mode 100644 index 0000000000..ace745f26c --- /dev/null +++ b/bindgen-tests/tests/headers/union_with_zero_sized_array.h @@ -0,0 +1,5 @@ +union U { + char d0[0]; + char d1[1]; + char d2[2]; +}; diff --git a/tests/headers/unknown_attr.h b/bindgen-tests/tests/headers/unknown_attr.h similarity index 83% rename from tests/headers/unknown_attr.h rename to bindgen-tests/tests/headers/unknown_attr.h index f87e9f0b3a..1e89fb14dd 100644 --- a/tests/headers/unknown_attr.h +++ b/bindgen-tests/tests/headers/unknown_attr.h @@ -1,6 +1,6 @@ typedef struct { long long __clang_max_align_nonce1 __attribute__((__aligned__(__alignof__(long long)))); - long double __clang_max_align_nonce2 + long long __clang_max_align_nonce2 __attribute__((__aligned__(__alignof__(long double)))); } max_align_t; diff --git a/bindgen-tests/tests/headers/unsorted-items.h b/bindgen-tests/tests/headers/unsorted-items.h new file mode 100644 index 0000000000..23962d18d8 --- /dev/null +++ b/bindgen-tests/tests/headers/unsorted-items.h @@ -0,0 +1,15 @@ +int foo(); +typedef int number; +int bar(number x); +struct Point +{ + number x; + number y; +}; +struct Angle +{ + number a; + number b; +}; +int baz(struct Point point); +const number NUMBER = 42; diff --git a/bindgen-tests/tests/headers/use-core.h b/bindgen-tests/tests/headers/use-core.h new file mode 100644 index 0000000000..5ee0ac6f39 --- /dev/null +++ b/bindgen-tests/tests/headers/use-core.h @@ -0,0 +1,13 @@ +// bindgen-flags: --use-core --raw-line '#![cfg(not(target_os="windows"))] extern crate core;' --with-derive-hash --with-derive-partialeq --with-derive-eq + +struct foo { + int a, b; + void* bar; +}; + +union { + int bar; + long baz; +} bazz; + +typedef void (*fooFunction)(int bar); diff --git a/tests/headers/using.hpp b/bindgen-tests/tests/headers/using.hpp similarity index 100% rename from tests/headers/using.hpp rename to bindgen-tests/tests/headers/using.hpp diff --git a/bindgen-tests/tests/headers/va_list_aarch64_linux.h b/bindgen-tests/tests/headers/va_list_aarch64_linux.h new file mode 100644 index 0000000000..7d2206a76e --- /dev/null +++ b/bindgen-tests/tests/headers/va_list_aarch64_linux.h @@ -0,0 +1,4 @@ +// bindgen-flags: -- --target=aarch64-unknown-linux-gnu + +typedef __builtin_va_list va_list; +int vprintf(const char* format, va_list vlist); diff --git a/bindgen-tests/tests/headers/var-tracing.hpp b/bindgen-tests/tests/headers/var-tracing.hpp new file mode 100644 index 0000000000..ef002a00f5 --- /dev/null +++ b/bindgen-tests/tests/headers/var-tracing.hpp @@ -0,0 +1,10 @@ +// bindgen-flags: --allowlist-type Baz + +struct Bar { + const int m_baz; + Bar(int baz); +}; + +class Baz { + static const Bar FOO[]; +}; diff --git a/bindgen-tests/tests/headers/variadic-method.hpp b/bindgen-tests/tests/headers/variadic-method.hpp new file mode 100644 index 0000000000..78a8eb45b5 --- /dev/null +++ b/bindgen-tests/tests/headers/variadic-method.hpp @@ -0,0 +1,6 @@ + +void foo(const char* fmt, ...); + +struct Bar { + void foo(const char* fmt, ...); +}; diff --git a/bindgen-tests/tests/headers/variadic-union.hpp b/bindgen-tests/tests/headers/variadic-union.hpp new file mode 100644 index 0000000000..62ed49fcc9 --- /dev/null +++ b/bindgen-tests/tests/headers/variadic-union.hpp @@ -0,0 +1,3 @@ +template union _Variadic_union { + _Variadic_union() = default; +}; diff --git a/bindgen-tests/tests/headers/variadic_template_function.hpp b/bindgen-tests/tests/headers/variadic_template_function.hpp new file mode 100644 index 0000000000..4942d8f024 --- /dev/null +++ b/bindgen-tests/tests/headers/variadic_template_function.hpp @@ -0,0 +1,6 @@ + +template +class VariadicFunctionObject { +public: + int add_em_up(T count,...); +}; diff --git a/bindgen-tests/tests/headers/vector.hpp b/bindgen-tests/tests/headers/vector.hpp new file mode 100644 index 0000000000..173aa02236 --- /dev/null +++ b/bindgen-tests/tests/headers/vector.hpp @@ -0,0 +1,9 @@ +struct foo { + __attribute__((__vector_size__(1 * sizeof(long long)))) long long mMember; +}; + +typedef float __m128 __attribute__ ((__vector_size__ (16))); +typedef double __m128d __attribute__((__vector_size__(16))); +typedef long long __m128i __attribute__((__vector_size__(16))); + +__m128 foo(__m128i, __m128d); diff --git a/tests/headers/virtual_dtor.hpp b/bindgen-tests/tests/headers/virtual_dtor.hpp similarity index 100% rename from tests/headers/virtual_dtor.hpp rename to bindgen-tests/tests/headers/virtual_dtor.hpp diff --git a/bindgen-tests/tests/headers/virtual_inheritance.hpp b/bindgen-tests/tests/headers/virtual_inheritance.hpp new file mode 100644 index 0000000000..b35378d881 --- /dev/null +++ b/bindgen-tests/tests/headers/virtual_inheritance.hpp @@ -0,0 +1,17 @@ +// bindgen-flags: --no-layout-tests +// FIXME: Enable layout tests when #465 is fixed. +class A { + int foo; +}; + +class B: public virtual A { + int bar; +}; + +class C: public virtual A { + int baz; +}; + +class D: public C, public B { + int bazz; +}; diff --git a/bindgen-tests/tests/headers/virtual_interface.hpp b/bindgen-tests/tests/headers/virtual_interface.hpp new file mode 100644 index 0000000000..00ab0737b7 --- /dev/null +++ b/bindgen-tests/tests/headers/virtual_interface.hpp @@ -0,0 +1,24 @@ +class PureVirtualIFace { +public: + virtual void Foo() = 0; + virtual void Bar(unsigned int) = 0; +}; + +class AnotherInterface { +public: + virtual void Baz() = 0; +}; + +class Implementation : public PureVirtualIFace { +public: + void Foo() override {} + void Bar(unsigned int) override {} +}; + +class DoubleImpl : public PureVirtualIFace, public AnotherInterface { +public: + void Foo() override {} + void Bar(unsigned int) override {} + + void Baz() override {} +}; diff --git a/bindgen-tests/tests/headers/virtual_overloaded.hpp b/bindgen-tests/tests/headers/virtual_overloaded.hpp new file mode 100644 index 0000000000..f5ba5ff2bd --- /dev/null +++ b/bindgen-tests/tests/headers/virtual_overloaded.hpp @@ -0,0 +1,5 @@ +class C { +public: + virtual void do_thing(char); + virtual void do_thing(int); +}; diff --git a/bindgen-tests/tests/headers/void_typedef.h b/bindgen-tests/tests/headers/void_typedef.h new file mode 100644 index 0000000000..405cbd0c46 --- /dev/null +++ b/bindgen-tests/tests/headers/void_typedef.h @@ -0,0 +1,9 @@ +typedef void VOID; + +typedef VOID ALSO_VOID; + +void this_api_returns_nothing(void); + +VOID this_api_also_returns_nothing(VOID); + +ALSO_VOID this_other_api_also_returns_nothing(ALSO_VOID); diff --git a/bindgen-tests/tests/headers/vtable_recursive_sig.hpp b/bindgen-tests/tests/headers/vtable_recursive_sig.hpp new file mode 100644 index 0000000000..8a073864bf --- /dev/null +++ b/bindgen-tests/tests/headers/vtable_recursive_sig.hpp @@ -0,0 +1,11 @@ +// bindgen-flags: -- -std=c++11 + +class Derived; +class Base { +public: + virtual Derived* AsDerived(); +}; + +class Derived final : public Base { + virtual Derived* AsDerived() override; +}; diff --git a/bindgen-tests/tests/headers/wasm-constructor-returns.hpp b/bindgen-tests/tests/headers/wasm-constructor-returns.hpp new file mode 100644 index 0000000000..9e47032708 --- /dev/null +++ b/bindgen-tests/tests/headers/wasm-constructor-returns.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --generate constructors,types -- -fvisibility=default --target=wasm32-unknown-emscripten + +class Foo { +public: + Foo(int var); +}; + diff --git a/bindgen-tests/tests/headers/wasm-import-module.h b/bindgen-tests/tests/headers/wasm-import-module.h new file mode 100644 index 0000000000..db4fe85c8d --- /dev/null +++ b/bindgen-tests/tests/headers/wasm-import-module.h @@ -0,0 +1,3 @@ +// bindgen-flags: --wasm-import-module-name test-module + +void test_function(); \ No newline at end of file diff --git a/tests/headers/weird_bitfields.hpp b/bindgen-tests/tests/headers/weird_bitfields.hpp similarity index 97% rename from tests/headers/weird_bitfields.hpp rename to bindgen-tests/tests/headers/weird_bitfields.hpp index 755681c1b1..b2761a804a 100644 --- a/tests/headers/weird_bitfields.hpp +++ b/bindgen-tests/tests/headers/weird_bitfields.hpp @@ -1,4 +1,5 @@ -// bindgen-flags: --no-unstable-rust +// bindgen-flags: --rustified-enum ".*" + // You can guess where this is taken from... enum nsStyleSVGOpacitySource { eStyleSVGOpacitySource_Normal, diff --git a/tests/headers/what_is_going_on.hpp b/bindgen-tests/tests/headers/what_is_going_on.hpp similarity index 100% rename from tests/headers/what_is_going_on.hpp rename to bindgen-tests/tests/headers/what_is_going_on.hpp diff --git a/bindgen-tests/tests/headers/win32-dtors.hpp b/bindgen-tests/tests/headers/win32-dtors.hpp new file mode 100644 index 0000000000..0f0f0e1604 --- /dev/null +++ b/bindgen-tests/tests/headers/win32-dtors.hpp @@ -0,0 +1,29 @@ +// bindgen-flags: -- --target=x86_64-pc-windows-msvc + +struct CppObj { + int x; + + CppObj(int x); + ~CppObj(); +}; + +struct CppObj2 { + int x; + + CppObj2(int x); + virtual ~CppObj2(); +}; + +struct CppObj3 : CppObj2 { + int x; + + CppObj3(int x); + virtual ~CppObj3(); +}; + +struct CppObj4 : CppObj2 { + int x; + + CppObj4(int x); + ~CppObj4(); +}; diff --git a/bindgen-tests/tests/headers/win32-thiscall.hpp b/bindgen-tests/tests/headers/win32-thiscall.hpp new file mode 100644 index 0000000000..4651f809a1 --- /dev/null +++ b/bindgen-tests/tests/headers/win32-thiscall.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --raw-line "#![cfg(not(test))]" -- --target=i686-pc-windows-msvc + +class Foo { + public: + void test(); + int test2(int var); +}; diff --git a/bindgen-tests/tests/headers/win32-thiscall_1_73.hpp b/bindgen-tests/tests/headers/win32-thiscall_1_73.hpp new file mode 100644 index 0000000000..8c240055b2 --- /dev/null +++ b/bindgen-tests/tests/headers/win32-thiscall_1_73.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --rust-target=1.73 --raw-line '#![cfg(target = "i686-pc-windows-msvc")]' -- --target=i686-pc-windows-msvc + +class Foo { + public: + void test(); + int test2(int var); +}; diff --git a/bindgen-tests/tests/headers/win32-thiscall_nightly.hpp b/bindgen-tests/tests/headers/win32-thiscall_nightly.hpp new file mode 100644 index 0000000000..2c9f2f1748 --- /dev/null +++ b/bindgen-tests/tests/headers/win32-thiscall_nightly.hpp @@ -0,0 +1,7 @@ +// bindgen-flags: --rust-target nightly --raw-line '#![cfg(feature = "nightly")]' --raw-line '#![feature(abi_thiscall)]' -- --target=i686-pc-windows-msvc + +class Foo { + public: + void test(); + int test2(int var); +}; diff --git a/bindgen-tests/tests/headers/win32-vectorcall-nightly.h b/bindgen-tests/tests/headers/win32-vectorcall-nightly.h new file mode 100644 index 0000000000..c099bb59a5 --- /dev/null +++ b/bindgen-tests/tests/headers/win32-vectorcall-nightly.h @@ -0,0 +1,3 @@ +// bindgen-flags: --rust-target nightly --raw-line '#![cfg(feature = "nightly")]' --raw-line '#![feature(abi_vectorcall)]' -- --target=x86_64-pc-windows-msvc + +int __vectorcall test_vectorcall(int a, int b); diff --git a/bindgen-tests/tests/headers/win32-vectorcall.h b/bindgen-tests/tests/headers/win32-vectorcall.h new file mode 100644 index 0000000000..3fe36f1004 --- /dev/null +++ b/bindgen-tests/tests/headers/win32-vectorcall.h @@ -0,0 +1,3 @@ +// bindgen-flags: -- --target=x86_64-pc-windows-msvc + +int __vectorcall test_vectorcall(int a, int b); diff --git a/bindgen-tests/tests/headers/with_array_pointers_arguments.h b/bindgen-tests/tests/headers/with_array_pointers_arguments.h new file mode 100644 index 0000000000..565b3cf678 --- /dev/null +++ b/bindgen-tests/tests/headers/with_array_pointers_arguments.h @@ -0,0 +1,10 @@ +// bindgen-flags: --use-array-pointers-in-arguments + +int test_fn(float a, int arr[20]); + +int test_fn2(const float arr[20], int b); + +typedef char defArr[20]; +typedef void foo(defArr a); + +void bar(defArr a); \ No newline at end of file diff --git a/bindgen-tests/tests/headers/without_array_pointers_arguments.h b/bindgen-tests/tests/headers/without_array_pointers_arguments.h new file mode 100644 index 0000000000..2f0668749b --- /dev/null +++ b/bindgen-tests/tests/headers/without_array_pointers_arguments.h @@ -0,0 +1,9 @@ + +int test_fn(float a, int arr[20]); + +int test_fn2(const float arr[20], int b); + +typedef char defArr[20]; +typedef void foo(defArr a); + +void bar(defArr a); \ No newline at end of file diff --git a/bindgen-tests/tests/headers/wrap-static-fns.h b/bindgen-tests/tests/headers/wrap-static-fns.h new file mode 100644 index 0000000000..a35e713f2b --- /dev/null +++ b/bindgen-tests/tests/headers/wrap-static-fns.h @@ -0,0 +1,91 @@ +// bindgen-flags: --wrap-static-fns +// bindgen-parse-callbacks: wrap-as-variadic-fn + +// to avoid polluting the expectation tests we put the stdarg.h behind a conditional +// variable only used in bindgen-integration +#ifdef USE_VA_HEADER +#include +#endif + +static inline int foo() { + return 11; +} +static int bar(); +static int bar() { + return 1; +} +inline int baz() { + return 2; +} + +static inline int takes_ptr(int* arg) { + return *arg + 1; +} + +static inline int takes_fn_ptr(int (*f)(int)) { + return f(1); +} + +static inline int takes_fn(int (f)(int)) { + return f(2); +} + +typedef int (func)(int); + +static inline int takes_alias(func f) { + return f(3); +} + +static inline int takes_qualified(const int *const *arg) { + return **arg; +} + +enum foo { + BAR = 0x0, +}; + +static inline enum foo takes_enum(const enum foo f) { + return f; +} + +static inline void nevermore() { + while (1) { } +} + +static inline int takes_fn_with_no_args(int(f)(void)) { + return f(); +} + +static inline int variadic(int x, ...) { + return x; +} + +// aarch64-linux has a bug, remove ifdef when it is solved: +// https://github.com/rust-lang/rust-bindgen/issues/3234 +#ifndef DISABLE_VA + +static inline void no_extra_argument(__builtin_va_list va) {} + +static inline int many_va_list(int i, __builtin_va_list va1, __builtin_va_list va2) { + return i; +} + +#ifndef USE_VA_HEADER +static inline int wrap_as_variadic_fn1(int i, __builtin_va_list va) { + return i; +} + +static inline void wrap_as_variadic_fn2(int i, __builtin_va_list va) {} +#else +static inline int wrap_as_variadic_fn1(int i, va_list va) { + int res = 0; + + for (int j = 0; j < i; j++) + res += (int) va_arg(va, int); + + return res; +} + +static inline void wrap_as_variadic_fn2(int i, va_list va) {} +#endif +#endif diff --git a/bindgen-tests/tests/headers/wrap_unsafe_ops_anon_union.hpp b/bindgen-tests/tests/headers/wrap_unsafe_ops_anon_union.hpp new file mode 100644 index 0000000000..34faea5d90 --- /dev/null +++ b/bindgen-tests/tests/headers/wrap_unsafe_ops_anon_union.hpp @@ -0,0 +1,22 @@ +// bindgen-flags: --wrap-unsafe-ops --no-layout-tests + +template +struct TErrorResult { + enum UnionState { + HasMessage, + HasException, + }; + int mResult; + struct Message; + struct DOMExceptionInfo; + union { + Message* mMessage; + DOMExceptionInfo* mDOMExceptionInfo; + }; + + bool mMightHaveUnreported; + UnionState mUnionState; +}; + +struct ErrorResult : public TErrorResult { +}; diff --git a/bindgen-tests/tests/headers/wrap_unsafe_ops_class.hpp b/bindgen-tests/tests/headers/wrap_unsafe_ops_class.hpp new file mode 100644 index 0000000000..e3d11c571b --- /dev/null +++ b/bindgen-tests/tests/headers/wrap_unsafe_ops_class.hpp @@ -0,0 +1,74 @@ +// bindgen-flags: --wrap-unsafe-ops --no-layout-tests + +class C { + int a; + // More than rust limits (32) + char big_array[33]; +}; + +class C_with_zero_length_array { + int a; + // More than rust limits (32) + char big_array[33]; + char zero_length_array[0]; +}; + +class C_with_zero_length_array_2 { + int a; + char zero_length_array[0]; +}; + +class C_with_incomplete_array { + int a; + // More than rust limits (32) + char big_array[33]; + char incomplete_array[]; +}; + +class C_with_incomplete_array_2 { + int a; + char incomplete_array[]; +}; + +class C_with_zero_length_array_and_incomplete_array { + int a; + // More than rust limits (32) + char big_array[33]; + char zero_length_array[0]; + char incomplete_array[]; +}; + +class C_with_zero_length_array_and_incomplete_array_2 { + int a; + char zero_length_array[0]; + char incomplete_array[]; +}; + +class WithDtor { + int b; + + ~WithDtor() {} +}; + +class IncompleteArrayNonCopiable { + void* whatever; + C incomplete_array[]; +}; + +union Union { + float d; + int i; +}; + +class WithUnion { + Union data; +}; + +class RealAbstractionWithTonsOfMethods { + void foo(); +public: + void bar() const; + void bar(); + void bar(int foo); + static void sta(); +}; diff --git a/bindgen-tests/tests/headers/wrap_unsafe_ops_dynamic_loading_simple.h b/bindgen-tests/tests/headers/wrap_unsafe_ops_dynamic_loading_simple.h new file mode 100644 index 0000000000..36a638ae2a --- /dev/null +++ b/bindgen-tests/tests/headers/wrap_unsafe_ops_dynamic_loading_simple.h @@ -0,0 +1,7 @@ +// bindgen-flags: --dynamic-loading TestLib --wrap-unsafe-ops + +int foo(int x, int y); +int bar(void *x); +int baz(); + +const int FLUX; diff --git a/bindgen-tests/tests/headers/wrap_unsafe_ops_objc_class.h b/bindgen-tests/tests/headers/wrap_unsafe_ops_objc_class.h new file mode 100644 index 0000000000..017795c85d --- /dev/null +++ b/bindgen-tests/tests/headers/wrap_unsafe_ops_objc_class.h @@ -0,0 +1,10 @@ +// bindgen-flags: --wrap-unsafe-ops -- -x objective-c +// bindgen-osx-only + +@class Foo; + +Foo* fooVar; + +@interface Foo +-(void)method; +@end diff --git a/bindgen-tests/tests/headers/zero-size-array-align.h b/bindgen-tests/tests/headers/zero-size-array-align.h new file mode 100644 index 0000000000..05b11bce57 --- /dev/null +++ b/bindgen-tests/tests/headers/zero-size-array-align.h @@ -0,0 +1,5 @@ +struct dm_deps { + unsigned count; + unsigned filler; + unsigned long long device[0]; +}; diff --git a/bindgen-tests/tests/headers/zero-sized-array.hpp b/bindgen-tests/tests/headers/zero-sized-array.hpp new file mode 100644 index 0000000000..ae6d05549c --- /dev/null +++ b/bindgen-tests/tests/headers/zero-sized-array.hpp @@ -0,0 +1,45 @@ +// These classes are technically zero-sized, but despite that they still don't +// get an `_address` field inserted. + +/** + * Bizarrely enough, this should *not* get an `_address` field. + */ +class ZeroSizedArray { + char arr[0]; +}; + +/** + * And nor should this get an `_address` field. + */ +class ContainsZeroSizedArray { + ZeroSizedArray zsa; +}; + +/** + * Inheriting from ZeroSizedArray shouldn't cause an `_address` to be inserted + * either. + */ +class InheritsZeroSizedArray : ZeroSizedArray {}; + +// These are dynamically sized, which means that `sizeof` yields `0` but it +// isn't really true. We shouldn't add an `_address` field to them. + +/** + * And this should not get an `_address` field either. + */ +class DynamicallySizedArray { + char arr[]; +}; + +/** + * No `_address` field here either. + */ +class ContainsDynamicallySizedArray { + DynamicallySizedArray dsa; +}; + +// Note: this is disallowed: +// +// error: base class 'DynamicallySizedArray' has a flexible array member +// +// class InheritsDynamicallySizedArray : DynamicallySizedArray {}; diff --git a/bindgen-tests/tests/macro_fallback_test_headers/another_header.h b/bindgen-tests/tests/macro_fallback_test_headers/another_header.h new file mode 100644 index 0000000000..b0c40eb43f --- /dev/null +++ b/bindgen-tests/tests/macro_fallback_test_headers/another_header.h @@ -0,0 +1,10 @@ +#ifndef ANOTHER_HEADER_H +#define ANOTHER_HEADER_H + +#include + +#define SHOULD_NOT_GENERATE UINT64_C(~0) +#define MY_CONST UINT32_C(69) +#define NEGATIVE ~0 + +#endif diff --git a/bindgen-tests/tests/macro_fallback_test_headers/one_header.h b/bindgen-tests/tests/macro_fallback_test_headers/one_header.h new file mode 100644 index 0000000000..5058814bba --- /dev/null +++ b/bindgen-tests/tests/macro_fallback_test_headers/one_header.h @@ -0,0 +1,8 @@ +#ifndef ONE_HEADER_H +#define ONE_HEADER_H + +#include + +#define THE_CONST UINT32_C(28) + +#endif diff --git a/bindgen-tests/tests/parse_callbacks/item_discovery_callback/header_item_discovery.h b/bindgen-tests/tests/parse_callbacks/item_discovery_callback/header_item_discovery.h new file mode 100644 index 0000000000..eb44e5fc58 --- /dev/null +++ b/bindgen-tests/tests/parse_callbacks/item_discovery_callback/header_item_discovery.h @@ -0,0 +1,32 @@ +// Structs +void function_using_anonymous_struct(struct {} arg0); + +struct NamedStruct { +}; + +typedef struct NamedStruct AliasOfNamedStruct; + + +// Unions +void function_using_anonymous_union(union {} arg0); + +union NamedUnion { +}; + +typedef union NamedUnion AliasOfNamedUnion; + +// Enums + +// We don't include an anonymous enum because such enums +// are not visible outside the function, and thus tend not +// to be useful - bindgen doesn't handle them for this reason. + +enum NamedEnum { + Fish, +}; + +typedef enum NamedEnum AliasOfNamedEnum; + +// Functions + +void named_function(); diff --git a/bindgen-tests/tests/parse_callbacks/item_discovery_callback/header_item_discovery.hpp b/bindgen-tests/tests/parse_callbacks/item_discovery_callback/header_item_discovery.hpp new file mode 100644 index 0000000000..1de8d99e4d --- /dev/null +++ b/bindgen-tests/tests/parse_callbacks/item_discovery_callback/header_item_discovery.hpp @@ -0,0 +1,6 @@ +// Methods + +class SomeClass { +public: + void named_method(); +}; \ No newline at end of file diff --git a/bindgen-tests/tests/parse_callbacks/item_discovery_callback/mod.rs b/bindgen-tests/tests/parse_callbacks/item_discovery_callback/mod.rs new file mode 100644 index 0000000000..a9a9523895 --- /dev/null +++ b/bindgen-tests/tests/parse_callbacks/item_discovery_callback/mod.rs @@ -0,0 +1,510 @@ +use std::cell::RefCell; +use std::collections::HashMap; +use std::rc::Rc; + +use regex::Regex; + +use bindgen::callbacks::{ + DiscoveredItem, DiscoveredItemId, ParseCallbacks, SourceLocation, +}; +use bindgen::Builder; + +#[derive(Debug, Default)] +struct ItemDiscovery(Rc>); + +pub type ItemCache = HashMap; + +#[derive(Debug)] +pub struct DiscoveredInformation(DiscoveredItem, Option); + +impl ParseCallbacks for ItemDiscovery { + fn new_item_found( + &self, + id: DiscoveredItemId, + item: DiscoveredItem, + source_location: Option<&SourceLocation>, + ) { + self.0 + .borrow_mut() + .insert(id, DiscoveredInformation(item, source_location.cloned())); + } +} + +#[derive(Debug)] +pub struct ItemExpectations { + item: DiscoveredItem, + source_location: Option<(usize, usize, usize)>, +} + +impl ItemExpectations { + fn new( + item: DiscoveredItem, + line: usize, + col: usize, + byte_offset: usize, + ) -> Self { + Self { + item, + source_location: Some((line, col, byte_offset)), + } + } +} + +type ExpectationMap = HashMap; + +fn test_item_discovery_callback( + header: &str, + expected: &HashMap, +) { + let discovery = ItemDiscovery::default(); + let info = Rc::clone(&discovery.0); + + let mut header_path = env!("CARGO_MANIFEST_DIR").to_string(); + header_path.push_str(header); + + Builder::default() + .header(header_path) + .parse_callbacks(Box::new(discovery)) + .generate() + .expect("TODO: panic message"); + + compare_item_caches(&info.borrow(), expected, header); +} + +#[test] +fn test_item_discovery_callback_c() { + let expected = ExpectationMap::from([ + ( + DiscoveredItemId::new(10), + ItemExpectations::new( + DiscoveredItem::Struct { + original_name: Some("NamedStruct".to_string()), + final_name: "NamedStruct".to_string(), + }, + 4, + 8, + 73, + ), + ), + ( + DiscoveredItemId::new(11), + ItemExpectations::new( + DiscoveredItem::Alias { + alias_name: "AliasOfNamedStruct".to_string(), + alias_for: DiscoveredItemId::new(10), + }, + 7, + 28, + 118, + ), + ), + ( + DiscoveredItemId::new(20), + ItemExpectations::new( + DiscoveredItem::Union { + original_name: Some("NamedUnion".to_string()), + final_name: "NamedUnion".to_string(), + }, + 13, + 7, + 209, + ), + ), + ( + DiscoveredItemId::new(21), + ItemExpectations::new( + DiscoveredItem::Alias { + alias_name: "AliasOfNamedUnion".to_string(), + alias_for: DiscoveredItemId::new(20), + }, + 16, + 26, + 251, + ), + ), + ( + DiscoveredItemId::new(27), + ItemExpectations::new( + DiscoveredItem::Alias { + alias_name: "AliasOfNamedEnum".to_string(), + alias_for: DiscoveredItemId::new(24), + }, + 28, + 24, + 515, + ), + ), + ( + DiscoveredItemId::new(24), + ItemExpectations::new( + DiscoveredItem::Enum { + final_name: "NamedEnum".to_string(), + }, + 24, + 6, + 466, + ), + ), + ( + DiscoveredItemId::new(30), + ItemExpectations::new( + DiscoveredItem::Struct { + original_name: None, + final_name: "_bindgen_ty_*".to_string(), + }, + 2, + 38, + 48, + ), + ), + ( + DiscoveredItemId::new(40), + ItemExpectations::new( + DiscoveredItem::Union { + original_name: None, + final_name: "_bindgen_ty_*".to_string(), + }, + 11, + 37, + 186, + ), + ), + ( + DiscoveredItemId::new(41), + ItemExpectations::new( + DiscoveredItem::Function { + final_name: "named_function".to_string(), + }, + 32, + 6, + 553, + ), + ), + ]); + test_item_discovery_callback( + "/tests/parse_callbacks/item_discovery_callback/header_item_discovery.h", &expected); +} + +#[test] +fn test_item_discovery_callback_cpp() { + let expected = ExpectationMap::from([ + ( + DiscoveredItemId::new(1), + ItemExpectations::new( + DiscoveredItem::Struct { + original_name: Some("SomeClass".to_string()), + final_name: "SomeClass".to_string(), + }, + 3, + 7, + 18, + ), + ), + ( + DiscoveredItemId::new(2), + ItemExpectations::new( + DiscoveredItem::Method { + final_name: "named_method".to_string(), + parent: DiscoveredItemId::new(1), + }, + 5, + 10, + 47, + ), + ), + ]); + test_item_discovery_callback( + "/tests/parse_callbacks/item_discovery_callback/header_item_discovery.hpp", &expected); +} + +fn compare_item_caches( + generated: &ItemCache, + expected: &ExpectationMap, + expected_filename: &str, +) { + // We can't use a simple Eq::eq comparison because of two reasons: + // - anonymous structs/unions will have a final name generated by bindgen which may change + // if the header file or the bindgen logic is altered + // - aliases have a DiscoveredItemId that we can't directly compare for the same instability reasons + for expected_item in expected.values() { + let found = generated.iter().find(|(_generated_id, generated_item)| { + compare_item_info( + expected_item, + generated_item, + expected, + generated, + expected_filename, + ) + }); + + assert!( + found.is_some(), + "Missing Expected Item: {expected_item:#?}\n in {generated:#?}" + ); + } +} + +fn compare_item_info( + expected_item: &ItemExpectations, + generated_item: &DiscoveredInformation, + expected: &ExpectationMap, + generated: &ItemCache, + expected_filename: &str, +) -> bool { + if std::mem::discriminant(&expected_item.item) != + std::mem::discriminant(&generated_item.0) + { + return false; + } + + let is_a_match = match generated_item.0 { + DiscoveredItem::Struct { .. } => { + compare_struct_info(&expected_item.item, &generated_item.0) + } + DiscoveredItem::Union { .. } => { + compare_union_info(&expected_item.item, &generated_item.0) + } + DiscoveredItem::Alias { .. } => compare_alias_info( + &expected_item.item, + &generated_item.0, + expected, + generated, + expected_filename, + ), + DiscoveredItem::Enum { .. } => { + compare_enum_info(&expected_item.item, &generated_item.0) + } + DiscoveredItem::Function { .. } => { + compare_function_info(&expected_item.item, &generated_item.0) + } + DiscoveredItem::Method { .. } => { + compare_method_info(&expected_item.item, &generated_item.0) + } + }; + + if is_a_match { + // Compare source location + assert!( + generated_item.1.is_some() == + expected_item.source_location.is_some(), + "No source location provided when one was expected" + ); + if let Some(generated_location) = generated_item.1.as_ref() { + let expected_location = expected_item.source_location.unwrap(); + assert!( + generated_location + .file_name + .as_ref() + .expect("No filename provided") + .ends_with(expected_filename), + "Filename differed" + ); + assert_eq!( + ( + generated_location.line, + generated_location.col, + generated_location.byte_offset + ), + expected_location, + "Line/col/offsets differ" + ); + } + } + is_a_match +} + +pub fn compare_names(expected_name: &str, generated_name: &str) -> bool { + if let Ok(regex) = Regex::new(expected_name) { + regex.is_match(generated_name) + } else { + false + } +} + +pub fn compare_struct_info( + expected_item: &DiscoveredItem, + generated_item: &DiscoveredItem, +) -> bool { + let DiscoveredItem::Struct { + original_name: expected_original_name, + final_name: expected_final_name, + } = expected_item + else { + unreachable!() + }; + + let DiscoveredItem::Struct { + original_name: generated_original_name, + final_name: generated_final_name, + } = generated_item + else { + unreachable!() + }; + + if !compare_names(expected_final_name, generated_final_name) { + return false; + } + + match (expected_original_name, generated_original_name) { + (None, None) => true, + (Some(expected_original_name), Some(generated_original_name)) => { + compare_names(expected_original_name, generated_original_name) + } + _ => false, + } +} + +pub fn compare_union_info( + expected_item: &DiscoveredItem, + generated_item: &DiscoveredItem, +) -> bool { + let DiscoveredItem::Union { + original_name: expected_original_name, + final_name: expected_final_name, + } = expected_item + else { + unreachable!() + }; + + let DiscoveredItem::Union { + original_name: generated_original_name, + final_name: generated_final_name, + } = generated_item + else { + unreachable!() + }; + + if !compare_names(expected_final_name, generated_final_name) { + return false; + } + + match (expected_original_name, generated_original_name) { + (None, None) => true, + (Some(expected_original_name), Some(generated_original_name)) => { + compare_names(expected_original_name, generated_original_name) + } + _ => false, + } +} + +pub fn compare_enum_info( + expected_item: &DiscoveredItem, + generated_item: &DiscoveredItem, +) -> bool { + let DiscoveredItem::Enum { + final_name: expected_final_name, + } = expected_item + else { + unreachable!() + }; + + let DiscoveredItem::Enum { + final_name: generated_final_name, + } = generated_item + else { + unreachable!() + }; + + if !compare_names(expected_final_name, generated_final_name) { + return false; + } + true +} + +pub fn compare_alias_info( + expected_item: &DiscoveredItem, + generated_item: &DiscoveredItem, + expected: &ExpectationMap, + generated: &ItemCache, + expected_filename: &str, +) -> bool { + let DiscoveredItem::Alias { + alias_name: expected_alias_name, + alias_for: expected_alias_for, + } = expected_item + else { + unreachable!() + }; + + let DiscoveredItem::Alias { + alias_name: generated_alias_name, + alias_for: generated_alias_for, + } = generated_item + else { + unreachable!() + }; + + if !compare_names(expected_alias_name, generated_alias_name) { + return false; + } + + // Assumes correct test definition + let expected_aliased = expected.get(expected_alias_for).unwrap(); + + // We must have the aliased type in the cache + let Some(generated_aliased) = generated.get(generated_alias_for) else { + return false; + }; + + compare_item_info( + expected_aliased, + generated_aliased, + expected, + generated, + expected_filename, + ) +} + +pub fn compare_function_info( + expected_item: &DiscoveredItem, + generated_item: &DiscoveredItem, +) -> bool { + let DiscoveredItem::Function { + final_name: expected_final_name, + } = expected_item + else { + unreachable!() + }; + + let DiscoveredItem::Function { + final_name: generated_final_name, + } = generated_item + else { + unreachable!() + }; + + if !compare_names(expected_final_name, generated_final_name) { + return false; + } + true +} + +pub fn compare_method_info( + expected_item: &DiscoveredItem, + generated_item: &DiscoveredItem, +) -> bool { + let DiscoveredItem::Method { + final_name: expected_final_name, + parent: expected_parent, + } = expected_item + else { + unreachable!() + }; + + let DiscoveredItem::Method { + final_name: generated_final_name, + parent: generated_parent, + } = generated_item + else { + unreachable!() + }; + + if expected_parent != generated_parent { + return false; + } + + if !compare_names(expected_final_name, generated_final_name) { + return false; + } + true +} diff --git a/bindgen-tests/tests/parse_callbacks/mod.rs b/bindgen-tests/tests/parse_callbacks/mod.rs new file mode 100644 index 0000000000..5fe8d90d4c --- /dev/null +++ b/bindgen-tests/tests/parse_callbacks/mod.rs @@ -0,0 +1,195 @@ +mod item_discovery_callback; + +use bindgen::callbacks::*; +use bindgen::FieldVisibilityKind; + +#[derive(Debug)] +pub struct RemovePrefixParseCallback { + pub remove_prefix: Option, +} + +impl RemovePrefixParseCallback { + pub fn new(prefix: &str) -> Self { + RemovePrefixParseCallback { + remove_prefix: Some(prefix.to_string()), + } + } +} + +impl ParseCallbacks for RemovePrefixParseCallback { + fn generated_name_override(&self, item_info: ItemInfo) -> Option { + if let Some(prefix) = &self.remove_prefix { + let (expected_prefix, expected_suffix) = match item_info.kind { + ItemKind::Function => ("function_", "_name"), + ItemKind::Var => ("var_", "_name"), + _ => todo!(), + }; + if let Some(name) = item_info.name.strip_prefix(prefix) { + assert!(name.starts_with(expected_prefix)); + assert!(name.ends_with(expected_suffix)); + return Some(name.to_string()); + } + } + None + } +} + +#[derive(Debug)] +pub struct PrefixLinkNameParseCallback { + pub prefix: Option, +} + +impl PrefixLinkNameParseCallback { + pub fn new(prefix: &str) -> Self { + PrefixLinkNameParseCallback { + prefix: Some(prefix.to_string()), + } + } +} + +impl ParseCallbacks for PrefixLinkNameParseCallback { + fn generated_link_name_override( + &self, + item_info: ItemInfo, + ) -> Option { + self.prefix + .as_deref() + .map(|prefix| format!("{prefix}{}", item_info.name)) + } +} + +#[derive(Debug)] +struct EnumVariantRename; + +impl ParseCallbacks for EnumVariantRename { + fn enum_variant_name( + &self, + _enum_name: Option<&str>, + original_variant_name: &str, + _variant_value: EnumVariantValue, + ) -> Option { + Some(format!("RENAMED_{original_variant_name}")) + } +} + +#[derive(Debug)] +struct BlocklistedTypeImplementsTrait; + +impl ParseCallbacks for BlocklistedTypeImplementsTrait { + fn blocklisted_type_implements_trait( + &self, + _name: &str, + derive_trait: DeriveTrait, + ) -> Option { + if derive_trait == DeriveTrait::Hash { + Some(ImplementsTrait::No) + } else { + Some(ImplementsTrait::Yes) + } + } +} + +#[derive(Debug)] +struct FieldVisibility { + default: FieldVisibilityKind, +} + +/// Implements the `field_visibility` function of the trait by checking if the +/// field name starts with `private_`. If it does, it makes it private, if it +/// doesn't, it makes it public, taking into account the default visibility. +impl ParseCallbacks for FieldVisibility { + fn field_visibility( + &self, + FieldInfo { field_name, .. }: FieldInfo, + ) -> Option { + match (self.default, field_name.starts_with("private_")) { + (FieldVisibilityKind::Private, false) => { + Some(FieldVisibilityKind::Public) + } + (FieldVisibilityKind::Public, true) => { + Some(FieldVisibilityKind::Private) + } + (FieldVisibilityKind::PublicCrate, _) => unimplemented!(), + _ => None, + } + } +} + +#[derive(Debug)] +struct TypeVisibility; + +/// Implements the `field_visibility` function of the trait by checking the +/// type name. Depending on name prefix, it will return a different visibility. +impl ParseCallbacks for TypeVisibility { + fn field_visibility( + &self, + FieldInfo { type_name, .. }: FieldInfo, + ) -> Option { + if type_name.starts_with("private_") { + Some(FieldVisibilityKind::Private) + } else if type_name.starts_with("pubcrate_") { + Some(FieldVisibilityKind::PublicCrate) + } else if type_name.starts_with("pub_") { + Some(FieldVisibilityKind::Public) + } else { + None + } + } +} + +#[derive(Debug)] +pub(super) struct WrapAsVariadicFn; + +impl ParseCallbacks for WrapAsVariadicFn { + fn wrap_as_variadic_fn(&self, name: &str) -> Option { + Some(name.to_owned() + "_wrapped") + } +} + +#[derive(Debug)] +pub(super) struct OperatorRename; + +impl ParseCallbacks for OperatorRename { + fn generated_name_override(&self, info: ItemInfo) -> Option { + if info.name == "operator=" { + Some("operatorequals".to_string()) + } else { + None + } + } +} + +pub fn lookup(cb: &str) -> Box { + match cb { + "enum-variant-rename" => Box::new(EnumVariantRename), + "blocklisted-type-implements-trait" => { + Box::new(BlocklistedTypeImplementsTrait) + } + "wrap-as-variadic-fn" => Box::new(WrapAsVariadicFn), + "type-visibility" => Box::new(TypeVisibility), + "operator-rename" => Box::new(OperatorRename), + call_back => { + if let Some(prefix) = + call_back.strip_prefix("remove-function-prefix-") + { + let lnopc = RemovePrefixParseCallback::new(prefix); + Box::new(lnopc) + } else if let Some(prefix) = + call_back.strip_prefix("prefix-link-name-") + { + let plnpc = PrefixLinkNameParseCallback::new(prefix); + Box::new(plnpc) + } else if let Some(default) = + call_back.strip_prefix("field-visibility-default-") + { + Box::new(FieldVisibility { + default: default.parse().expect( + "unable to parse field-visibility-default callback", + ), + }) + } else { + panic!("Couldn't find name ParseCallbacks: {cb}") + } + } + } +} diff --git a/bindgen-tests/tests/quickchecking/.gitignore b/bindgen-tests/tests/quickchecking/.gitignore new file mode 100644 index 0000000000..03314f77b5 --- /dev/null +++ b/bindgen-tests/tests/quickchecking/.gitignore @@ -0,0 +1 @@ +Cargo.lock diff --git a/bindgen-tests/tests/quickchecking/Cargo.toml b/bindgen-tests/tests/quickchecking/Cargo.toml new file mode 100644 index 0000000000..b26ba3b392 --- /dev/null +++ b/bindgen-tests/tests/quickchecking/Cargo.toml @@ -0,0 +1,34 @@ +lints.workspace = true + +[package] +name = "quickchecking" +description = "Bindgen property tests with quickcheck. Generate random valid C code and pass it to the csmith/predicate.py script" +version = "0.0.0" +publish = false +rust-version.workspace = true +edition.workspace = true + +[lib] +name = "quickchecking" +path = "src/lib.rs" + +[[bin]] +name = "quickchecking" +path = "src/bin.rs" + +[dependencies] +clap.workspace = true +quickcheck.workspace = true +tempfile.workspace = true + +[features] +# No features by default. +default = [] + +# Enable the generation of code that allows for zero sized arrays as struct +# fields. Until issues #684 and #1153 are resolved this can result in failing tests. +zero-sized-arrays = [] + +# Enable the generation of code that allows for long double types as struct +# fields. Until issue #550 is resolved this can result in failing tests. +long-doubles = [] diff --git a/bindgen-tests/tests/quickchecking/README.md b/bindgen-tests/tests/quickchecking/README.md new file mode 100644 index 0000000000..03aa0f2313 --- /dev/null +++ b/bindgen-tests/tests/quickchecking/README.md @@ -0,0 +1,40 @@ +# Property tests for `bindgen` with `quickchecking` + +`quickchecking` generates random C headers to test `bindgen` +using the [`quickcheck`] property testing crate. When testing +`bindgen` with `quickchecking`, the generated header files are passed to +`bindgen`'s `csmith-fuzzing/predicate.py` script. If that script fails, +`quickchecking` panics, and you can report an issue containing the test case! + + + + + +- [Prerequisites](#prerequisites) +- [Running](#running) + + + +## Prerequisites + +Requires `python3` to be in `$PATH`. + +Many systems have `python3` by default but if your OS doesn't, its package +manager may make it available: + +``` +$ sudo apt install python3 +$ brew install python3 +$ # Etc... +``` + +## Running + +Run `quickchecking` binary to generate and test fuzzed C headers with +`cargo run`. Additional configuration is exposed through the binary's CLI. + +``` +$ cargo run --bin=quickchecking -- -h +``` + +[`quickcheck`]: https://github.com/BurntSushi/quickcheck diff --git a/bindgen-tests/tests/quickchecking/src/bin.rs b/bindgen-tests/tests/quickchecking/src/bin.rs new file mode 100644 index 0000000000..3072bc7b46 --- /dev/null +++ b/bindgen-tests/tests/quickchecking/src/bin.rs @@ -0,0 +1,110 @@ +//! An application to run property tests for `bindgen` with _fuzzed_ C headers +//! using `quickcheck` +//! +//! ## Usage +//! +//! Print help +//! ```bash +//! $ cargo run --bin=quickchecking -- -h +//! ``` +//! +//! Run with default values +//! ```bash +//! $ cargo run --bin=quickchecking +//! ``` +//! +#![deny(missing_docs)] + +use clap::{Arg, ArgAction, Command}; +use std::path::PathBuf; + +// Parse CLI argument input for generation range. +fn parse_generate_range(v: &str) -> Result { + match v.parse::() { + Ok(v) => Ok(v), + Err(_) => Err(String::from( + "Generate range could not be converted to a usize.", + )), + } +} + +// Parse CLI argument input for tests count. +fn parse_tests_count(v: &str) -> Result { + match v.parse::() { + Ok(v) => Ok(v), + Err(_) => Err(String::from( + "Tests count could not be converted to a usize.", + )), + } +} + +// Parse CLI argument input for fuzzed headers output path. +fn parse_path(v: &str) -> Result { + let path = PathBuf::from(v); + if path.is_dir() { + Ok(path) + } else { + Err(String::from("Provided directory path does not exist.")) + } +} + +fn main() { + let matches = Command::new("quickchecking") + .version("0.2.0") + .about( + "Bindgen property tests with quickcheck. \ + Generate random valid C code and pass it to the \ + csmith/predicate.py script", + ) + .arg( + Arg::new("path") + .short('p') + .long("path") + .value_name("PATH") + .help( + "Optional. Preserve generated headers for inspection, \ + provide directory path for header output. [default: None] ", + ) + .action(ArgAction::Set) + .value_parser(parse_path), + ) + .arg( + Arg::new("range") + .short('r') + .long("range") + .value_name("RANGE") + .help( + "Sets the range quickcheck uses during generation. \ + Corresponds to things like arbitrary usize and \ + arbitrary vector length. This number doesn't have \ + to grow much for execution time to increase \ + significantly.", + ) + .action(ArgAction::Set) + .default_value("32") + .value_parser(parse_generate_range), + ) + .arg( + Arg::new("count") + .short('c') + .long("count") + .value_name("COUNT") + .help( + "Count / number of tests to run. Running a fuzzed \ + header through the predicate.py script can take a \ + long time, especially if the generation range is \ + large. Increase this number if you're willing to \ + wait a while.", + ) + .action(ArgAction::Set) + .default_value("2") + .value_parser(parse_tests_count), + ) + .get_matches(); + + let output_path = matches.get_one::("path").map(PathBuf::as_path); + let generate_range = *matches.get_one::("range").unwrap(); + let tests = *matches.get_one::("count").unwrap(); + + quickchecking::test_bindgen(generate_range, tests, output_path); +} diff --git a/bindgen-tests/tests/quickchecking/src/fuzzers.rs b/bindgen-tests/tests/quickchecking/src/fuzzers.rs new file mode 100644 index 0000000000..176636f66f --- /dev/null +++ b/bindgen-tests/tests/quickchecking/src/fuzzers.rs @@ -0,0 +1,633 @@ +use quickcheck::{Arbitrary, Gen}; +use std::fmt; +use std::fmt::Write as _; + +/// `BaseTypeC` is used in generation of C headers to represent the C language's +/// primitive types as well as `void*`. +#[derive(Debug, Clone)] +pub struct BaseTypeC { + /// String representation of C type. + pub def: String, +} + +/// `TypeQualifierC` is used in generation of C headers to represent qualifiers +/// such as `const`. +#[derive(Debug, Clone)] +pub struct TypeQualifierC { + /// String representation of C type qualifier. + pub def: String, +} + +/// `PointerLevelC` is used in generation of C headers to represent number of +/// `*` for pointer types. +#[derive(Debug, Clone)] +pub struct PointerLevelC { + /// String representation of C declaration's pointer level. + pub def: String, +} + +/// `ArrayDimensionC` is used in generation of C headers to represent number of +/// `[]` used to define array types. +#[derive(Debug, Clone)] +pub struct ArrayDimensionC { + /// String representation of C declaration's array dimension. + pub def: String, +} + +/// `BasicTypeDeclarationC` is used in generation of C headers to represent +/// declarations outside of function pointers that take the form +/// `BaseTypeC` + `TypeQualifierC` + `PointerLevelC` + `ident_id`. +#[derive(Debug, Clone)] +pub struct BasicTypeDeclarationC { + /// The declaration's base type, i.e. `int`. + pub type_name: BaseTypeC, + /// The declaration's type qualifier, i.e. `const`. + pub type_qualifier: TypeQualifierC, + /// The declaration's pointer level, i.e. `***`. + pub pointer_level: PointerLevelC, + /// The declaration's array dimension, i.e. [][][]. + pub array_dimension: ArrayDimensionC, + /// The declaration's identifier, i.e. `ident_N`. + pub ident_id: String, +} + +/// `StructDeclarationC` is used in generation of C headers to represent the +/// definition of a struct type. +#[derive(Debug, Clone)] +pub struct StructDeclarationC { + /// The declaration's fields. + pub fields: DeclarationListC, + /// The declaration's array dimension, i.e. [][][]. + pub array_dimension: ArrayDimensionC, + /// The declaration's identifier, i.e. `struct_N`. + pub ident_id: String, +} + +/// `UnionDeclarationC` is used in generation of C headers to represent the +/// definition of a union type. +#[derive(Debug, Clone)] +pub struct UnionDeclarationC { + /// The declaration's fields. + pub fields: DeclarationListC, + /// The declaration's array dimension, i.e. [][][]. + pub array_dimension: ArrayDimensionC, + /// The declaration's identifier, i.e. `union_N`. + pub ident_id: String, +} + +/// `FunctionPointerDeclarationC` is used in generation of C headers to represent +/// the definition of a function pointer type. +#[derive(Debug, Clone)] +pub struct FunctionPointerDeclarationC { + /// The function's type qualifier, i.e. `const`. + pub type_qualifier: TypeQualifierC, + /// The function's return type, i.e. `int`. + pub type_name: BaseTypeC, + /// The function's pointer level, i.e. `***`. + pub pointer_level: PointerLevelC, + /// The function's parameters. + pub params: ParameterListC, + /// The declaration's identifier, i.e. `func_ptr_N`. + pub ident_id: String, +} + +/// `FunctionPrototypeC` is used in generation of C headers to represent the +/// definition of a function prototype. +#[derive(Debug, Clone)] +pub struct FunctionPrototypeC { + /// The function's type qualifier, i.e. `const`. + pub type_qualifier: TypeQualifierC, + /// The function's return type, i.e. `int`. + pub type_name: BaseTypeC, + /// The function's pointer level, i.e. `***`. + pub pointer_level: PointerLevelC, + /// The function's parameters. + pub params: ParameterListC, + /// The prototype's identifier, i.e. `func_N`. + pub ident_id: String, +} + +/// `ParameterC` is used in generation of C headers to represent the +/// definition function parameters. +#[derive(Debug, Clone)] +pub struct ParameterC { + /// The parameter's type qualifier, i.e. `const`. + pub type_qualifier: TypeQualifierC, + /// The parameter's base type, i.e. `int`. + pub type_name: BaseTypeC, + /// The parameter's pointer level, i.e. `***`. + pub pointer_level: PointerLevelC, +} + +/// `ParameterListC` is used in generation of C headers to represent a list of +/// definitions of function parameters. +#[derive(Debug, Clone)] +pub struct ParameterListC { + /// Parameters that define a C function signature. + pub params: Vec, +} + +/// `DeclarationC` is used in generation of C headers to represent all supported +/// C type declarations allowed in the generated header. +#[derive(Debug, Clone)] +pub enum DeclarationC { + /// Function prototype declaration kind. + FunctionDecl(FunctionPrototypeC), + /// Function pointer declaration kind. + FunctionPtrDecl(FunctionPointerDeclarationC), + /// Struct declaration kind. + StructDecl(StructDeclarationC), + /// Union declaration kind. + UnionDecl(UnionDeclarationC), + /// Basic type declaration kind. + VariableDecl(BasicTypeDeclarationC), +} + +/// `DeclarationListC` is used in generation of C headers to represent a list of +/// declarations. +#[derive(Debug, Clone)] +pub struct DeclarationListC { + /// Grouping of C declarations. + pub decls: Vec, +} + +/// `HeaderC` is used in generation of C headers to represent a collection of +/// declarations. +#[derive(Clone)] +pub struct HeaderC { + /// The header's declarations. + pub def: DeclarationListC, +} + +/// `MakeUnique` is used in generation of C headers to make declaration +/// identifiers unique by incorporating the `stamp` parameter into it's name. +trait MakeUnique { + fn make_unique(&mut self, stamp: usize); +} + +/// `MakeUnique` is used in generation of C headers to make `DeclarationC` +/// identifiers unique. +impl MakeUnique for DeclarationC { + fn make_unique(&mut self, stamp: usize) { + match *self { + DeclarationC::FunctionDecl(ref mut d) => d.make_unique(stamp), + DeclarationC::FunctionPtrDecl(ref mut d) => d.make_unique(stamp), + DeclarationC::StructDecl(ref mut d) => d.make_unique(stamp), + DeclarationC::UnionDecl(ref mut d) => d.make_unique(stamp), + DeclarationC::VariableDecl(ref mut d) => d.make_unique(stamp), + } + } +} + +/// A qucickcheck trait for describing how `DeclarationC` types can be +/// randomly generated and shrunk. +impl Arbitrary for DeclarationC { + fn arbitrary(g: &mut Gen) -> DeclarationC { + match gen_range(g, 0, 5) { + 0 => DeclarationC::FunctionDecl(FunctionPrototypeC::arbitrary(g)), + 1 => DeclarationC::FunctionPtrDecl( + FunctionPointerDeclarationC::arbitrary(g), + ), + 2 => DeclarationC::StructDecl(StructDeclarationC::arbitrary(g)), + 3 => DeclarationC::UnionDecl(UnionDeclarationC::arbitrary(g)), + 4 => { + DeclarationC::VariableDecl(BasicTypeDeclarationC::arbitrary(g)) + } + _ => unreachable!(), + } + } +} + +/// Enables to string and format for `DeclarationC` types. +impl fmt::Display for DeclarationC { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match *self { + DeclarationC::FunctionPtrDecl(ref d) => write!(f, "{d}"), + DeclarationC::StructDecl(ref d) => write!(f, "{d}"), + DeclarationC::UnionDecl(ref d) => write!(f, "{d}"), + DeclarationC::VariableDecl(ref d) => write!(f, "{d}"), + DeclarationC::FunctionDecl(ref d) => write!(f, "{d}"), + } + } +} + +/// A qucickcheck trait for describing how `DeclarationListC` types can be +/// randomly generated and shrunk. +impl Arbitrary for DeclarationListC { + fn arbitrary(g: &mut Gen) -> DeclarationListC { + DeclarationListC { + decls: Arbitrary::arbitrary(g), + } + } +} + +/// Enables to string and format for `DeclarationListC` types. +impl fmt::Display for DeclarationListC { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + for decl in &self.decls { + write!(f, "{decl}")?; + } + Ok(()) + } +} + +/// A quickcheck trait for describing how `BaseTypeC` types can be +/// randomly generated and shrunk. +impl Arbitrary for BaseTypeC { + fn arbitrary(g: &mut Gen) -> BaseTypeC { + // Special case `long double` until issue #550 is resolved. + let base_type = vec![ + "char", + "signed char", + "unsigned char", + "short", + "short int", + "signed short", + "signed short int", + "unsigned short", + "unsigned short int", + "int", + "signed", + "signed int", + "unsigned", + "unsigned int", + "long", + "long int", + "signed long", + "signed long int", + "unsigned long", + "unsigned long int", + "long long", + "long long int", + "signed long long", + "signed long long int", + "unsigned long long", + "unsigned long long int", + "float", + "double", + #[cfg(feature = "long-doubles")] + "long double", + "void*", + ]; + BaseTypeC { + def: String::from(*g.choose(&base_type).unwrap()), + } + } +} + +/// Enables to string and format for `BaseTypeC` types, +impl fmt::Display for BaseTypeC { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.def) + } +} + +/// A qucickcheck trait for describing how `TypeQualifierC` types can be +/// randomly generated and shrunk. +impl Arbitrary for TypeQualifierC { + fn arbitrary(g: &mut Gen) -> TypeQualifierC { + let qualifier = vec!["const", ""]; + TypeQualifierC { + def: String::from(*g.choose(&qualifier).unwrap()), + } + } +} + +/// Enables to string and format for `TypeQualifierC` types. +impl fmt::Display for TypeQualifierC { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.def) + } +} + +/// A qucickcheck trait for describing how `PointerLevelC` types can be +/// randomly generated and shrunk. +impl Arbitrary for PointerLevelC { + fn arbitrary(g: &mut Gen) -> PointerLevelC { + PointerLevelC { + // 16 is an arbitrary "not too big" number for capping pointer level. + def: (0..gen_range(g, 0, 16)).map(|_| "*").collect::(), + } + } +} + +/// Enables to string and format for `PointerLevelC` types. +impl fmt::Display for PointerLevelC { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.def) + } +} + +/// A qucickcheck trait for describing how `ArrayDimensionC` types can be +/// randomly generated and shrunk. +impl Arbitrary for ArrayDimensionC { + fn arbitrary(g: &mut Gen) -> ArrayDimensionC { + // Keep these small, clang complains when they get too big. + let dimensions = gen_range(g, 0, 5); + let mut def = String::new(); + + let lower_bound = u64::from(cfg!(feature = "zero-sized-arrays")); + + for _ in 1..dimensions { + // 16 is an arbitrary "not too big" number for capping array size. + let _ = write!(def, "[{}]", gen_range(g, lower_bound, 16)); + } + ArrayDimensionC { def } + } +} + +/// Enables to string and format for `ArrayDimensionC` types. +impl fmt::Display for ArrayDimensionC { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.def) + } +} + +/// `MakeUnique` is used in generation of C headers to make `BasicTypeDeclarationC` +/// identifiers unique. +impl MakeUnique for BasicTypeDeclarationC { + fn make_unique(&mut self, stamp: usize) { + let _ = write!(self.ident_id, "_{stamp}"); + } +} + +/// A qucickcheck trait for describing how `BasicTypeDeclarationC` types can be +/// randomly generated and shrunk. +impl Arbitrary for BasicTypeDeclarationC { + fn arbitrary(g: &mut Gen) -> BasicTypeDeclarationC { + BasicTypeDeclarationC { + type_qualifier: Arbitrary::arbitrary(g), + type_name: Arbitrary::arbitrary(g), + pointer_level: Arbitrary::arbitrary(g), + array_dimension: Arbitrary::arbitrary(g), + ident_id: format!("{}", usize::arbitrary(g)), + } + } +} + +/// Enables to string and format for `BasicTypeDeclarationC` types. +impl fmt::Display for BasicTypeDeclarationC { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!( + f, + "{} {} {} ident_{}{};", + self.type_qualifier, + self.type_name, + self.pointer_level, + self.ident_id, + self.array_dimension + ) + } +} + +/// `MakeUnique` is used in generation of C headers to make `StructDeclarationC` +/// identifiers unique. +impl MakeUnique for StructDeclarationC { + fn make_unique(&mut self, stamp: usize) { + let _ = write!(self.ident_id, "_{stamp}"); + } +} + +/// A qucickcheck trait for describing how `StructDeclarationC` types can be +/// randomly generated and shrunk. +impl Arbitrary for StructDeclarationC { + fn arbitrary(g: &mut Gen) -> StructDeclarationC { + // Reduce generator size as a method of putting a bound on recursion. + // When size < 1 the empty list is generated. + let reduced_size: usize = (g.size() / 2) + 1; + let mut decl_list: DeclarationListC = + Arbitrary::arbitrary(&mut Gen::new(reduced_size)); + let mut fields: DeclarationListC = DeclarationListC { decls: vec![] }; + + for (i, decl) in decl_list.decls.iter_mut().enumerate() { + match *decl { + DeclarationC::FunctionDecl(_) => {} + ref mut decl => { + decl.make_unique(i); + fields.decls.push(decl.clone()); + } + } + } + + StructDeclarationC { + fields, + ident_id: format!("{}", usize::arbitrary(g)), + array_dimension: Arbitrary::arbitrary(g), + } + } +} + +/// Enables to string and format for `StructDeclarationC` types. +impl fmt::Display for StructDeclarationC { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!( + f, + "struct {{ {} }} struct_{}{};", + self.fields, self.ident_id, self.array_dimension + ) + } +} + +/// `MakeUnique` is used in generation of C headers to make `UnionDeclarationC` +/// identifiers unique. +impl MakeUnique for UnionDeclarationC { + fn make_unique(&mut self, stamp: usize) { + let _ = write!(self.ident_id, "_{stamp}"); + } +} + +/// A qucickcheck trait for describing how `UnionDeclarationC` types can be +/// randomly generated and shrunk. +impl Arbitrary for UnionDeclarationC { + fn arbitrary(g: &mut Gen) -> UnionDeclarationC { + // Reduce generator size as a method of putting a bound on recursion. + // When size < 1 the empty list is generated. + let reduced_size: usize = (g.size() / 2) + 1; + let mut decl_list: DeclarationListC = + Arbitrary::arbitrary(&mut Gen::new(reduced_size)); + let mut fields: DeclarationListC = DeclarationListC { decls: vec![] }; + + for (i, decl) in decl_list.decls.iter_mut().enumerate() { + match *decl { + DeclarationC::FunctionDecl(_) => {} + ref mut decl => { + decl.make_unique(i); + fields.decls.push(decl.clone()); + } + } + } + + UnionDeclarationC { + fields, + ident_id: format!("{}", usize::arbitrary(g)), + array_dimension: Arbitrary::arbitrary(g), + } + } +} + +/// Enables to string and format for `UnionDeclarationC` types. +impl fmt::Display for UnionDeclarationC { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!( + f, + "union {{ {} }} union_{}{};", + self.fields, self.ident_id, self.array_dimension + ) + } +} + +/// `MakeUnique` is used in generation of C headers to make +/// `FunctionPointerDeclarationC` identifiers unique. +impl MakeUnique for FunctionPointerDeclarationC { + fn make_unique(&mut self, stamp: usize) { + let _ = write!(self.ident_id, "_{stamp}"); + } +} + +/// A qucickcheck trait for describing how `FunctionPointerDeclarationC` types can +/// be randomly generated and shrunk. +impl Arbitrary for FunctionPointerDeclarationC { + fn arbitrary(g: &mut Gen) -> FunctionPointerDeclarationC { + FunctionPointerDeclarationC { + type_qualifier: Arbitrary::arbitrary(g), + type_name: Arbitrary::arbitrary(g), + pointer_level: Arbitrary::arbitrary(g), + params: Arbitrary::arbitrary(g), + ident_id: format!("{}", usize::arbitrary(g)), + } + } +} + +/// Enables to string and format for `FunctionPointerDeclarationC` types. +impl fmt::Display for FunctionPointerDeclarationC { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!( + f, + "{} {} {} (*func_ptr_{})({});", + self.type_qualifier, + self.type_name, + self.pointer_level, + self.ident_id, + self.params + ) + } +} + +/// `MakeUnique` is used in generation of C headers to make `FunctionPrototypeC` +/// identifiers unique. +impl MakeUnique for FunctionPrototypeC { + fn make_unique(&mut self, stamp: usize) { + let _ = write!(self.ident_id, "_{stamp}"); + } +} + +/// A qucickcheck trait for describing how `FunctionPrototypeC` types can be +/// randomly generated and shrunk. +impl Arbitrary for FunctionPrototypeC { + fn arbitrary(g: &mut Gen) -> FunctionPrototypeC { + FunctionPrototypeC { + type_qualifier: Arbitrary::arbitrary(g), + type_name: Arbitrary::arbitrary(g), + pointer_level: Arbitrary::arbitrary(g), + params: Arbitrary::arbitrary(g), + ident_id: format!("{}", usize::arbitrary(g)), + } + } +} + +/// Enables to string and format for `FunctionPrototypeC` types. +impl fmt::Display for FunctionPrototypeC { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!( + f, + "{} {} {} func_{}({});", + self.type_qualifier, + self.type_name, + self.pointer_level, + self.ident_id, + self.params + ) + } +} + +/// A qucickcheck trait for describing how `ParameterC` types can be +/// randomly generated and shrunk. +impl Arbitrary for ParameterC { + fn arbitrary(g: &mut Gen) -> ParameterC { + ParameterC { + type_qualifier: Arbitrary::arbitrary(g), + type_name: Arbitrary::arbitrary(g), + pointer_level: Arbitrary::arbitrary(g), + } + } +} + +/// Enables to string and format for `ParameterC` types. +impl fmt::Display for ParameterC { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!( + f, + "{} {} {}", + self.type_qualifier, self.type_name, self.pointer_level + ) + } +} + +/// A qucickcheck trait for describing how `ParameterListC` types can be +/// randomly generated and shrunk. +impl Arbitrary for ParameterListC { + fn arbitrary(g: &mut Gen) -> ParameterListC { + ParameterListC { + params: Arbitrary::arbitrary(g), + } + } +} + +/// Enables to string and format for `ParameterListC` types. +impl fmt::Display for ParameterListC { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + for (i, p) in self.params.iter().enumerate() { + match i { + 0 => write!(f, "{p}")?, + _ => write!(f, ",{p}")?, + } + } + Ok(()) + } +} + +/// A qucickcheck trait for describing how `HeaderC` types can be +/// randomly generated and shrunk. +impl Arbitrary for HeaderC { + fn arbitrary(g: &mut Gen) -> HeaderC { + let mut decl_list: DeclarationListC = Arbitrary::arbitrary(g); + for (i, decl) in decl_list.decls.iter_mut().enumerate() { + decl.make_unique(i); + } + HeaderC { def: decl_list } + } +} + +/// Enables to string and format for `HeaderC` types. +impl fmt::Display for HeaderC { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + for decl in &self.def.decls { + write!(f, "{decl}")?; + } + Ok(()) + } +} + +/// Use Display trait for Debug so that any failing property tests report +/// generated C code rather than the data structures that contain it. +impl fmt::Debug for HeaderC { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{self}") + } +} + +/// FIXME: is this actually uniform? +fn gen_range(gen: &mut Gen, lo: u64, hi: u64) -> u64 { + let len = hi - lo; + (u64::arbitrary(gen) % len) + lo +} diff --git a/bindgen-tests/tests/quickchecking/src/lib.rs b/bindgen-tests/tests/quickchecking/src/lib.rs new file mode 100644 index 0000000000..7567a3bea6 --- /dev/null +++ b/bindgen-tests/tests/quickchecking/src/lib.rs @@ -0,0 +1,108 @@ +//! A library to generate __fuzzed__ C headers for use with `quickcheck` +//! +//! ## Example +//! +//! ```rust +//! use quickcheck::{Arbitrary, Gen}; +//! use quickchecking::fuzzers; +//! +//! let generate_range: usize = 10; // Determines things like the length of +//! // arbitrary vectors generated. +//! let header = fuzzers::HeaderC::arbitrary(&mut Gen::new(generate_range)); +//! println!("{header}"); +//! ``` +#![deny(missing_docs)] + +use quickcheck::{Gen, QuickCheck, TestResult}; +use std::error::Error; +use std::fs::File; +use std::io::Write; +use std::path::{Path, PathBuf}; +use std::process::{Command, Output}; +use std::sync::Mutex; +use tempfile::Builder; + +/// Contains definitions of and impls for types used to fuzz C declarations. +pub mod fuzzers; + +// Global singleton, manages context across tests. For now that context is +// only the output_path for inspecting fuzzed headers (if specified). +struct Context { + output_path: Option, +} + +// Initialize global context. +static CONTEXT: Mutex = Mutex::new(Context { output_path: None }); + +// Passes fuzzed header to the `csmith-fuzzing/predicate.py` script, returns +// output of the associated command. +fn run_predicate_script( + header: &fuzzers::HeaderC, +) -> Result> { + let dir = Builder::new().prefix("bindgen_prop").tempdir()?; + let header_path = dir.path().join("prop_test.h"); + + let mut header_file = File::create(&header_path)?; + header_file.write_all(header.to_string().as_bytes())?; + header_file.sync_all()?; + + let header_path_string = header_path + .into_os_string() + .into_string() + .map_err(|_| "error converting path into String")?; + + let mut predicate_script_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")); + predicate_script_path.push("../../csmith-fuzzing/predicate.py"); + + let predicate_script_path_string = predicate_script_path + .into_os_string() + .into_string() + .map_err(|_| "error converting path into String")?; + + // Copy generated temp files to output_path directory for inspection. + // If `None`, output path not specified, don't copy. + if let Some(ref path) = CONTEXT.lock().unwrap().output_path { + Command::new("cp") + .arg("-a") + .arg(dir.path().to_str().unwrap()) + .arg(path) + .output()?; + } + + Ok(Command::new(predicate_script_path_string) + .arg(&header_path_string) + .output()?) +} + +// Generatable property. Pass generated headers off to run through the +// `csmith-fuzzing/predicate.py` script. Success is measured by the success +// status of that command. +#[allow(clippy::needless_pass_by_value)] +fn bindgen_prop(header: fuzzers::HeaderC) -> TestResult { + match run_predicate_script(&header) { + Ok(o) => TestResult::from_bool(o.status.success()), + Err(e) => { + println!("{e:?}"); + TestResult::from_bool(false) + } + } +} + +/// Instantiate a Quickcheck object and use it to run property tests using +/// fuzzed C headers generated with types defined in the `fuzzers` module. +/// Success/Failure is dictated by the result of passing the fuzzed headers +/// to the `csmith-fuzzing/predicate.py` script. +pub fn test_bindgen( + generate_range: usize, + tests: u64, + output_path: Option<&Path>, +) { + if let Some(path) = output_path { + CONTEXT.lock().unwrap().output_path = Some(path.display().to_string()); + } + + QuickCheck::new() + .tests(tests) + .gen(Gen::new(generate_range)) + .quickcheck(bindgen_prop as fn(fuzzers::HeaderC) -> TestResult); +} diff --git a/bindgen-tests/tests/quickchecking/tests/fuzzed-c-headers.rs b/bindgen-tests/tests/quickchecking/tests/fuzzed-c-headers.rs new file mode 100644 index 0000000000..0735a70c47 --- /dev/null +++ b/bindgen-tests/tests/quickchecking/tests/fuzzed-c-headers.rs @@ -0,0 +1,90 @@ +use quickcheck::{Arbitrary, Gen}; +use quickchecking::fuzzers::{ + ArrayDimensionC, BaseTypeC, BasicTypeDeclarationC, DeclarationC, + DeclarationListC, FunctionPointerDeclarationC, FunctionPrototypeC, HeaderC, + ParameterC, ParameterListC, PointerLevelC, StructDeclarationC, + TypeQualifierC, UnionDeclarationC, +}; +#[test] +fn test_declaraion_c_does_not_panic() { + let gen = &mut Gen::new(50); + let _: DeclarationC = Arbitrary::arbitrary(gen); +} + +#[test] +fn test_declaraion_list_c_does_not_panic() { + let gen = &mut Gen::new(50); + let _: DeclarationListC = Arbitrary::arbitrary(gen); +} + +#[test] +fn test_base_type_c_does_not_panic() { + let gen = &mut Gen::new(50); + let _: BaseTypeC = Arbitrary::arbitrary(gen); +} + +#[test] +fn test_type_qualifier_c_does_not_panic() { + let gen = &mut Gen::new(50); + let _: TypeQualifierC = Arbitrary::arbitrary(gen); +} + +#[test] +fn test_pointer_level_c_does_not_panic() { + let gen = &mut Gen::new(50); + let _: PointerLevelC = Arbitrary::arbitrary(gen); +} + +#[test] +fn test_array_dimension_c_does_not_panic() { + let gen = &mut Gen::new(50); + let _: ArrayDimensionC = Arbitrary::arbitrary(gen); +} + +#[test] +fn test_basic_type_declaration_c_does_not_panic() { + let gen = &mut Gen::new(50); + let _: BasicTypeDeclarationC = Arbitrary::arbitrary(gen); +} + +#[test] +fn test_struct_declaration_c_does_not_panic() { + let gen = &mut Gen::new(50); + let _: StructDeclarationC = Arbitrary::arbitrary(gen); +} + +#[test] +fn test_union_declaration_c_does_not_panic() { + let gen = &mut Gen::new(50); + let _: UnionDeclarationC = Arbitrary::arbitrary(gen); +} + +#[test] +fn test_function_pointer_declaration_c_does_not_panic() { + let gen = &mut Gen::new(50); + let _: FunctionPointerDeclarationC = Arbitrary::arbitrary(gen); +} + +#[test] +fn test_function_prototype_c_does_not_panic() { + let gen = &mut Gen::new(50); + let _: FunctionPrototypeC = Arbitrary::arbitrary(gen); +} + +#[test] +fn test_parameter_c_does_not_panic() { + let gen = &mut Gen::new(50); + let _: ParameterC = Arbitrary::arbitrary(gen); +} + +#[test] +fn test_parameter_list_c_does_not_panic() { + let gen = &mut Gen::new(50); + let _: ParameterListC = Arbitrary::arbitrary(gen); +} + +#[test] +fn test_header_c_does_not_panic() { + let gen = &mut Gen::new(50); + let _: HeaderC = Arbitrary::arbitrary(gen); +} diff --git a/bindgen-tests/tests/rustfmt.toml b/bindgen-tests/tests/rustfmt.toml new file mode 100644 index 0000000000..2564ccb5d7 --- /dev/null +++ b/bindgen-tests/tests/rustfmt.toml @@ -0,0 +1,3 @@ +normalize_doc_attributes = true +max_width = 80 +binop_separator = "back" diff --git a/bindgen-tests/tests/stylo.hpp b/bindgen-tests/tests/stylo.hpp new file mode 100644 index 0000000000..8810290365 --- /dev/null +++ b/bindgen-tests/tests/stylo.hpp @@ -0,0 +1,177914 @@ +# 1 "stylo.cpp" +# 1 "" 1 +# 1 "" 3 +# 352 "" 3 +# 1 "" 1 +# 1 "" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla-config.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla-config.h" +#pragma clang diagnostic push + +#pragma clang diagnostic ignored "-Wreserved-id-macro" +# 213 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla-config.h" +#pragma clang diagnostic pop +# 223 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla-config.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Char16.h" 1 +# 184 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Char16.h" +typedef const char16_t* char16ptr_t; + + + +static_assert(sizeof(char16_t) == 2, "Is char16_t type 16 bits?"); +static_assert(char16_t(-1) > char16_t(0), "Is char16_t type unsigned?"); +static_assert(sizeof(u'A') == 2, "Is unicode char literal 16 bits?"); +static_assert(sizeof(u""[0]) == 2, "Is unicode string char 16 bits?"); +# 224 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla-config.h" 2 +# 2 "" 2 +# 1 "stylo.cpp" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stdint.h" 1 3 +# 63 "/usr/local/bin/../lib/clang/3.9.1/include/stdint.h" 3 +# 1 "/usr/include/stdint.h" 1 3 4 +# 25 "/usr/include/stdint.h" 3 4 +# 1 "/usr/include/features.h" 1 3 4 +# 346 "/usr/include/features.h" 3 4 +# 1 "/usr/include/stdc-predef.h" 1 3 4 +# 347 "/usr/include/features.h" 2 3 4 +# 368 "/usr/include/features.h" 3 4 +# 1 "/usr/include/sys/cdefs.h" 1 3 4 +# 415 "/usr/include/sys/cdefs.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 416 "/usr/include/sys/cdefs.h" 2 3 4 +# 369 "/usr/include/features.h" 2 3 4 +# 392 "/usr/include/features.h" 3 4 +# 1 "/usr/include/gnu/stubs.h" 1 3 4 +# 10 "/usr/include/gnu/stubs.h" 3 4 +# 1 "/usr/include/gnu/stubs-64.h" 1 3 4 +# 11 "/usr/include/gnu/stubs.h" 2 3 4 +# 393 "/usr/include/features.h" 2 3 4 +# 26 "/usr/include/stdint.h" 2 3 4 +# 1 "/usr/include/bits/wchar.h" 1 3 4 +# 27 "/usr/include/stdint.h" 2 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/stdint.h" 2 3 4 + + + + + + + + +typedef signed char int8_t; +typedef short int int16_t; +typedef int int32_t; + +typedef long int int64_t; + + + + + + + +typedef unsigned char uint8_t; +typedef unsigned short int uint16_t; + +typedef unsigned int uint32_t; + + + +typedef unsigned long int uint64_t; +# 65 "/usr/include/stdint.h" 3 4 +typedef signed char int_least8_t; +typedef short int int_least16_t; +typedef int int_least32_t; + +typedef long int int_least64_t; + + + + + + +typedef unsigned char uint_least8_t; +typedef unsigned short int uint_least16_t; +typedef unsigned int uint_least32_t; + +typedef unsigned long int uint_least64_t; +# 90 "/usr/include/stdint.h" 3 4 +typedef signed char int_fast8_t; + +typedef long int int_fast16_t; +typedef long int int_fast32_t; +typedef long int int_fast64_t; +# 103 "/usr/include/stdint.h" 3 4 +typedef unsigned char uint_fast8_t; + +typedef unsigned long int uint_fast16_t; +typedef unsigned long int uint_fast32_t; +typedef unsigned long int uint_fast64_t; +# 119 "/usr/include/stdint.h" 3 4 +typedef long int intptr_t; + + +typedef unsigned long int uintptr_t; +# 134 "/usr/include/stdint.h" 3 4 +typedef long int intmax_t; +typedef unsigned long int uintmax_t; +# 64 "/usr/local/bin/../lib/clang/3.9.1/include/stdint.h" 2 3 +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2 + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoTypes.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoTypes.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h" 1 +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Attributes.h" 1 +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Attributes.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Compiler.h" 1 +# 49 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Compiler.h" +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstddef" 1 3 +# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstddef" 3 + + + + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 1 3 + + +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 4 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 2 3 +# 2106 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 3 +namespace std +{ + typedef long unsigned int size_t; + typedef long int ptrdiff_t; + + + typedef decltype(nullptr) nullptr_t; + +} +# 2128 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 3 +namespace std +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +namespace __gnu_cxx +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +# 2414 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/os_defines.h" 1 3 +# 2415 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/cpu_defines.h" 1 3 +# 2418 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 2 3 +# 50 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstddef" 2 3 +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 +# 51 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 3 +typedef long int ptrdiff_t; +# 62 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 3 +typedef long unsigned int size_t; +# 118 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 3 +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/__stddef_max_align_t.h" 1 3 +# 35 "/usr/local/bin/../lib/clang/3.9.1/include/__stddef_max_align_t.h" 3 +typedef struct { + long long __clang_max_align_nonce1 + __attribute__((__aligned__(__alignof__(long long)))); + long double __clang_max_align_nonce2 + __attribute__((__aligned__(__alignof__(long double)))); +} max_align_t; +# 119 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 2 3 +# 51 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstddef" 2 3 + + +namespace std +{ + + using ::max_align_t; +} +# 50 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Compiler.h" 2 +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Attributes.h" 2 +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IntegerTypeTraits.h" 1 +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IntegerTypeTraits.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" 1 +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Types.h" 1 +# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Types.h" +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 +# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Types.h" 2 +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" 2 + + + + + + + +# 1 "/usr/include/wchar.h" 1 3 4 +# 36 "/usr/include/wchar.h" 3 4 +# 1 "/usr/include/stdio.h" 1 3 4 +# 44 "/usr/include/stdio.h" 3 4 +struct _IO_FILE; + + + +typedef struct _IO_FILE FILE; +# 64 "/usr/include/stdio.h" 3 4 +typedef struct _IO_FILE __FILE; +# 37 "/usr/include/wchar.h" 2 3 4 + + +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stdarg.h" 1 3 4 +# 30 "/usr/local/bin/../lib/clang/3.9.1/include/stdarg.h" 3 4 +typedef __builtin_va_list va_list; +# 50 "/usr/local/bin/../lib/clang/3.9.1/include/stdarg.h" 3 4 +typedef __builtin_va_list __gnuc_va_list; +# 40 "/usr/include/wchar.h" 2 3 4 +# 51 "/usr/include/wchar.h" 3 4 +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4 +# 132 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 3 4 +typedef unsigned int wint_t; +# 52 "/usr/include/wchar.h" 2 3 4 +# 82 "/usr/include/wchar.h" 3 4 +typedef struct +{ + int __count; + union + { + + unsigned int __wch; + + + + char __wchb[4]; + } __value; +} __mbstate_t; +# 106 "/usr/include/wchar.h" 3 4 +typedef __mbstate_t mbstate_t; +# 132 "/usr/include/wchar.h" 3 4 +extern "C" { + + + + +struct tm; +# 147 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcscpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern wchar_t *wcsncpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern wchar_t *wcscat (wchar_t *__restrict __dest, + const wchar_t *__restrict __src) + throw () __attribute__ ((__nonnull__ (1, 2))); + +extern wchar_t *wcsncat (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw (); + + +extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2, + size_t __n) throw (); + + + + +# 1 "/usr/include/xlocale.h" 1 3 4 +# 27 "/usr/include/xlocale.h" 3 4 +typedef struct __locale_struct +{ + + struct __locale_data *__locales[13]; + + + const unsigned short int *__ctype_b; + const int *__ctype_tolower; + const int *__ctype_toupper; + + + const char *__names[13]; +} *__locale_t; + + +typedef __locale_t locale_t; +# 184 "/usr/include/wchar.h" 2 3 4 + +extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2, + __locale_t __loc) throw (); + +extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2, + size_t __n, __locale_t __loc) throw (); + + + + + +extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw (); + + + +extern size_t wcsxfrm (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n) throw (); +# 209 "/usr/include/wchar.h" 3 4 +extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2, + __locale_t __loc) throw (); + + + + +extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2, + size_t __n, __locale_t __loc) throw (); + + +extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__)); +# 230 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc) + throw () __attribute__ ((__pure__)); +# 240 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc) + throw () __attribute__ ((__pure__)); + + + + + + +extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc) + throw () __attribute__ ((__pure__)); + + + + + +extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject) + throw () __attribute__ ((__pure__)); + + +extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept) + throw () __attribute__ ((__pure__)); +# 269 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept) + throw () __attribute__ ((__pure__)); +# 280 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle) + throw () __attribute__ ((__pure__)); + + + +extern wchar_t *wcstok (wchar_t *__restrict __s, + const wchar_t *__restrict __delim, + wchar_t **__restrict __ptr) throw (); + + +extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__)); +# 302 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle) + throw () __attribute__ ((__pure__)); + + + + + +extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen) + throw () __attribute__ ((__pure__)); +# 323 "/usr/include/wchar.h" 3 4 +extern wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n) + throw () __attribute__ ((__pure__)); + + + +extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) + throw () __attribute__ ((__pure__)); + + +extern wchar_t *wmemcpy (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n) throw (); + + + +extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n) + throw (); + + +extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw (); + + + + + +extern wchar_t *wmempcpy (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n) + throw (); + + + + + + +extern wint_t btowc (int __c) throw (); + + + +extern int wctob (wint_t __c) throw (); + + + +extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__)); + + + +extern size_t mbrtowc (wchar_t *__restrict __pwc, + const char *__restrict __s, size_t __n, + mbstate_t *__restrict __p) throw (); + + +extern size_t wcrtomb (char *__restrict __s, wchar_t __wc, + mbstate_t *__restrict __ps) throw (); + + +extern size_t __mbrlen (const char *__restrict __s, size_t __n, + mbstate_t *__restrict __ps) throw (); +extern size_t mbrlen (const char *__restrict __s, size_t __n, + mbstate_t *__restrict __ps) throw (); +# 411 "/usr/include/wchar.h" 3 4 +extern size_t mbsrtowcs (wchar_t *__restrict __dst, + const char **__restrict __src, size_t __len, + mbstate_t *__restrict __ps) throw (); + + + +extern size_t wcsrtombs (char *__restrict __dst, + const wchar_t **__restrict __src, size_t __len, + mbstate_t *__restrict __ps) throw (); + + + + + + +extern size_t mbsnrtowcs (wchar_t *__restrict __dst, + const char **__restrict __src, size_t __nmc, + size_t __len, mbstate_t *__restrict __ps) throw (); + + + +extern size_t wcsnrtombs (char *__restrict __dst, + const wchar_t **__restrict __src, + size_t __nwc, size_t __len, + mbstate_t *__restrict __ps) throw (); + + + + + + +extern int wcwidth (wchar_t __c) throw (); + + + +extern int wcswidth (const wchar_t *__s, size_t __n) throw (); + + + + + + +extern double wcstod (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) throw (); + + + + + +extern float wcstof (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) throw (); +extern long double wcstold (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) throw (); + + + + + + + +extern long int wcstol (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) throw (); + + + +extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + throw (); + + + + + + +__extension__ +extern long long int wcstoll (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + throw (); + + + +__extension__ +extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base) throw (); + + + + + + +__extension__ +extern long long int wcstoq (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + throw (); + + + +__extension__ +extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base) throw (); +# 533 "/usr/include/wchar.h" 3 4 +extern long int wcstol_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base, + __locale_t __loc) throw (); + +extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base, __locale_t __loc) throw (); + +__extension__ +extern long long int wcstoll_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base, __locale_t __loc) throw (); + +__extension__ +extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base, __locale_t __loc) + throw (); + +extern double wcstod_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, __locale_t __loc) + throw (); + +extern float wcstof_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, __locale_t __loc) + throw (); + +extern long double wcstold_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + __locale_t __loc) throw (); + + + + + + +extern wchar_t *wcpcpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src) throw (); + + + +extern wchar_t *wcpncpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + throw (); + + + + + + +extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw (); + + + + + + +extern int fwide (__FILE *__fp, int __mode) throw (); + + + + + + +extern int fwprintf (__FILE *__restrict __stream, + const wchar_t *__restrict __format, ...) + ; + + + + +extern int wprintf (const wchar_t *__restrict __format, ...) + ; + +extern int swprintf (wchar_t *__restrict __s, size_t __n, + const wchar_t *__restrict __format, ...) + throw () ; + + + + + +extern int vfwprintf (__FILE *__restrict __s, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + + + + +extern int vwprintf (const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + + +extern int vswprintf (wchar_t *__restrict __s, size_t __n, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + throw () ; + + + + + + +extern int fwscanf (__FILE *__restrict __stream, + const wchar_t *__restrict __format, ...) + ; + + + + +extern int wscanf (const wchar_t *__restrict __format, ...) + ; + +extern int swscanf (const wchar_t *__restrict __s, + const wchar_t *__restrict __format, ...) + throw () ; +# 692 "/usr/include/wchar.h" 3 4 +extern int vfwscanf (__FILE *__restrict __s, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + + + + +extern int vwscanf (const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + +extern int vswscanf (const wchar_t *__restrict __s, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + throw () ; +# 748 "/usr/include/wchar.h" 3 4 +extern wint_t fgetwc (__FILE *__stream); +extern wint_t getwc (__FILE *__stream); + + + + + +extern wint_t getwchar (void); + + + + + + +extern wint_t fputwc (wchar_t __wc, __FILE *__stream); +extern wint_t putwc (wchar_t __wc, __FILE *__stream); + + + + + +extern wint_t putwchar (wchar_t __wc); + + + + + + + +extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n, + __FILE *__restrict __stream); + + + + + +extern int fputws (const wchar_t *__restrict __ws, + __FILE *__restrict __stream); + + + + + + +extern wint_t ungetwc (wint_t __wc, __FILE *__stream); +# 804 "/usr/include/wchar.h" 3 4 +extern wint_t getwc_unlocked (__FILE *__stream); +extern wint_t getwchar_unlocked (void); + + + + + + + +extern wint_t fgetwc_unlocked (__FILE *__stream); + + + + + + + +extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream); +# 830 "/usr/include/wchar.h" 3 4 +extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream); +extern wint_t putwchar_unlocked (wchar_t __wc); +# 840 "/usr/include/wchar.h" 3 4 +extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n, + __FILE *__restrict __stream); + + + + + + + +extern int fputws_unlocked (const wchar_t *__restrict __ws, + __FILE *__restrict __stream); + + + + + + + +extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize, + const wchar_t *__restrict __format, + const struct tm *__restrict __tp) throw (); + + + + + + + +extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize, + const wchar_t *__restrict __format, + const struct tm *__restrict __tp, + __locale_t __loc) throw (); +# 894 "/usr/include/wchar.h" 3 4 +} +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" 2 + +namespace mozilla { + + + +template struct RemoveCV; +template struct AddRvalueReference; +# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +typename AddRvalueReference::Type DeclVal(); + + + + + + + +template +struct IntegralConstant +{ + static constexpr T value = Value; + typedef T ValueType; + typedef IntegralConstant Type; +}; + + +typedef IntegralConstant TrueType; +typedef IntegralConstant FalseType; + + + + + +namespace detail { + +template +struct IsVoidHelper : FalseType {}; + +template<> +struct IsVoidHelper : TrueType {}; + +} +# 80 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsVoid : detail::IsVoidHelper::Type> {}; + +namespace detail { + +template +struct IsIntegralHelper : FalseType {}; + +template<> struct IsIntegralHelper : TrueType {}; +template<> struct IsIntegralHelper : TrueType {}; +template<> struct IsIntegralHelper : TrueType {}; +template<> struct IsIntegralHelper : TrueType {}; +template<> struct IsIntegralHelper : TrueType {}; +template<> struct IsIntegralHelper : TrueType {}; +template<> struct IsIntegralHelper : TrueType {}; +template<> struct IsIntegralHelper : TrueType {}; +template<> struct IsIntegralHelper : TrueType {}; +template<> struct IsIntegralHelper : TrueType {}; +template<> struct IsIntegralHelper : TrueType {}; +template<> struct IsIntegralHelper : TrueType {}; +template<> struct IsIntegralHelper : TrueType {}; +template<> struct IsIntegralHelper : TrueType {}; + +} +# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsIntegral : detail::IsIntegralHelper::Type> +{}; + +template +struct IsSame; + +namespace detail { + +template +struct IsFloatingPointHelper + : IntegralConstant::value || + IsSame::value || + IsSame::value> +{}; + +} +# 142 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsFloatingPoint + : detail::IsFloatingPointHelper::Type> +{}; + +namespace detail { + +template +struct IsArrayHelper : FalseType {}; + +template +struct IsArrayHelper : TrueType {}; + +template +struct IsArrayHelper : TrueType {}; + +} +# 168 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsArray : detail::IsArrayHelper::Type> +{}; + +namespace detail { + +template +struct IsFunPtr; + +template +struct IsFunPtr + : public FalseType +{}; + +template +struct IsFunPtr + : public TrueType +{}; + +}; +# 201 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsFunction + : public detail::IsFunPtr::Type *> +{}; + +namespace detail { + +template +struct IsPointerHelper : FalseType {}; + +template +struct IsPointerHelper : TrueType {}; + +} +# 231 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsPointer : detail::IsPointerHelper::Type> +{}; +# 246 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsLvalueReference : FalseType {}; + +template +struct IsLvalueReference : TrueType {}; +# 263 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsRvalueReference : FalseType {}; + +template +struct IsRvalueReference : TrueType {}; + +namespace detail { + + +template +struct IsEnumHelper + : IntegralConstant +{}; + +} +# 286 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsEnum + : detail::IsEnumHelper::Type> +{}; + +namespace detail { + + + + + +template +struct IsClassHelper + : IntegralConstant +{}; + +} +# 313 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsClass + : detail::IsClassHelper::Type> +{}; +# 334 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsReference + : IntegralConstant::value || IsRvalueReference::value> +{}; +# 348 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsArithmetic + : IntegralConstant::value || IsFloatingPoint::value> +{}; + +namespace detail { + +template +struct IsMemberPointerHelper : FalseType {}; + +template +struct IsMemberPointerHelper : TrueType {}; + +} +# 370 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsMemberPointer + : detail::IsMemberPointerHelper::Type> +{}; +# 382 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsScalar + : IntegralConstant::value || IsEnum::value || + IsPointer::value || IsMemberPointer::value> +{}; +# 397 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsConst : FalseType {}; + +template +struct IsConst : TrueType {}; +# 410 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsVolatile : FalseType {}; + +template +struct IsVolatile : TrueType {}; +# 424 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsPod : public FalseType {}; + +template<> struct IsPod : TrueType {}; +template<> struct IsPod : TrueType {}; +template<> struct IsPod : TrueType {}; +template<> struct IsPod : TrueType {}; +template<> struct IsPod : TrueType {}; +template<> struct IsPod : TrueType {}; +template<> struct IsPod : TrueType {}; +template<> struct IsPod : TrueType {}; +template<> struct IsPod : TrueType {}; +template<> struct IsPod : TrueType {}; +template<> struct IsPod : TrueType {}; +template<> struct IsPod : TrueType {}; +template<> struct IsPod : TrueType {}; +template<> struct IsPod : TrueType {}; +template<> struct IsPod : TrueType {}; +template<> struct IsPod : TrueType {}; +template struct IsPod : TrueType {}; + +namespace detail { + + + + + +template +struct IsEmptyHelper + : IntegralConstant::value && __is_empty(T)> +{}; + +} +# 498 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsEmpty : detail::IsEmptyHelper::Type> +{}; + + +namespace detail { + +template::value, + bool = IsIntegral::value, + typename NoCV = typename RemoveCV::Type> +struct IsSignedHelper; + + +template +struct IsSignedHelper : TrueType {}; + + +template +struct IsSignedHelper + : IntegralConstant +{}; + + +template +struct IsSignedHelper : FalseType {}; + +} +# 536 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsSigned : detail::IsSignedHelper {}; + +namespace detail { + +template::value, + bool = IsIntegral::value, + typename NoCV = typename RemoveCV::Type> +struct IsUnsignedHelper; + + +template +struct IsUnsignedHelper : FalseType {}; + + +template +struct IsUnsignedHelper + : IntegralConstant::value || bool(NoCV(1) < NoCV(-1)))> +{}; + + +template +struct IsUnsignedHelper : FalseType {}; + +} +# 572 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsUnsigned : detail::IsUnsignedHelper {}; + +namespace detail { + +struct DoIsDefaultConstructibleImpl +{ + template + static TrueType test(int); + template + static FalseType test(...); +}; + +template +struct IsDefaultConstructibleImpl : public DoIsDefaultConstructibleImpl +{ + typedef decltype(test(0)) Type; +}; + +} +# 611 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsDefaultConstructible + : public detail::IsDefaultConstructibleImpl::Type +{}; + +namespace detail { + +struct DoIsDestructibleImpl +{ + template().~T())> + static TrueType test(int); + template + static FalseType test(...); +}; + +template +struct IsDestructibleImpl : public DoIsDestructibleImpl +{ + typedef decltype(test(0)) Type; +}; + +} +# 645 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsDestructible : public detail::IsDestructibleImpl::Type {}; +# 662 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsSame : FalseType {}; + +template +struct IsSame : TrueType {}; + +namespace detail { + + + +template +struct BaseOfTester : IntegralConstant {}; +# 727 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +} +# 741 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsBaseOf + : IntegralConstant::value> +{}; + +namespace detail { + +template +struct ConvertibleTester +{ +private: + template + static char test_helper(To1); + + template + static decltype(test_helper(DeclVal())) test(int); + + template + static int test(...); + +public: + static const bool value = + sizeof(test(0)) == sizeof(char); +}; + +} +# 793 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct IsConvertible + : IntegralConstant::value> +{}; + +template +struct IsConvertible + : IntegralConstant::value> +{}; + +template +struct IsConvertible + : IntegralConstant::value> +{}; + +template<> +struct IsConvertible + : TrueType +{}; +# 825 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct RemoveConst +{ + typedef T Type; +}; + +template +struct RemoveConst +{ + typedef T Type; +}; +# 845 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct RemoveVolatile +{ + typedef T Type; +}; + +template +struct RemoveVolatile +{ + typedef T Type; +}; +# 865 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct RemoveCV +{ + typedef typename RemoveConst::Type>::Type Type; +}; +# 881 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct RemoveReference +{ + typedef T Type; +}; + +template +struct RemoveReference +{ + typedef T Type; +}; + +template +struct RemoveReference +{ + typedef T Type; +}; + +template +struct Conditional; + +namespace detail { + +enum Voidness { TIsVoid, TIsNotVoid }; + +template::value ? TIsVoid : TIsNotVoid> +struct AddLvalueReferenceHelper; + +template +struct AddLvalueReferenceHelper +{ + typedef void Type; +}; + +template +struct AddLvalueReferenceHelper +{ + typedef T& Type; +}; + +} +# 937 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct AddLvalueReference + : detail::AddLvalueReferenceHelper +{}; + +namespace detail { + +template::value ? TIsVoid : TIsNotVoid> +struct AddRvalueReferenceHelper; + +template +struct AddRvalueReferenceHelper +{ + typedef void Type; +}; + +template +struct AddRvalueReferenceHelper +{ + typedef T&& Type; +}; + +} +# 976 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct AddRvalueReference + : detail::AddRvalueReferenceHelper +{}; + + + +template +struct EnableIf; + +namespace detail { + +template +struct WithC : Conditional +{}; + +template +struct WithV : Conditional +{}; + + +template +struct WithCV : WithC::Type> +{}; + +template +struct CorrespondingSigned; + +template<> +struct CorrespondingSigned { typedef signed char Type; }; +template<> +struct CorrespondingSigned { typedef signed char Type; }; +template<> +struct CorrespondingSigned { typedef short Type; }; +template<> +struct CorrespondingSigned { typedef int Type; }; +template<> +struct CorrespondingSigned { typedef long Type; }; +template<> +struct CorrespondingSigned { typedef long long Type; }; + +template::Type, + bool IsSignedIntegerType = IsSigned::value && + !IsSame::value> +struct MakeSigned; + +template +struct MakeSigned +{ + typedef T Type; +}; + +template +struct MakeSigned + : WithCV::value, IsVolatile::value, + typename CorrespondingSigned::Type> +{}; + +} +# 1059 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct MakeSigned + : EnableIf::value && + !IsSame::Type>::value, + typename detail::MakeSigned + >::Type +{}; + +namespace detail { + +template +struct CorrespondingUnsigned; + +template<> +struct CorrespondingUnsigned { typedef unsigned char Type; }; +template<> +struct CorrespondingUnsigned { typedef unsigned char Type; }; +template<> +struct CorrespondingUnsigned { typedef unsigned short Type; }; +template<> +struct CorrespondingUnsigned { typedef unsigned int Type; }; +template<> +struct CorrespondingUnsigned { typedef unsigned long Type; }; +template<> +struct CorrespondingUnsigned { typedef unsigned long long Type; }; + + +template::Type, + bool IsUnsignedIntegerType = IsUnsigned::value && + !IsSame::value> +struct MakeUnsigned; + +template +struct MakeUnsigned +{ + typedef T Type; +}; + +template +struct MakeUnsigned + : WithCV::value, IsVolatile::value, + typename CorrespondingUnsigned::Type> +{}; + +} +# 1128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct MakeUnsigned + : EnableIf::value && + !IsSame::Type>::value, + typename detail::MakeUnsigned + >::Type +{}; +# 1147 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct RemoveExtent +{ + typedef T Type; +}; + +template +struct RemoveExtent +{ + typedef T Type; +}; + +template +struct RemoveExtent +{ + typedef T Type; +}; + + + +namespace detail { + +template +struct RemovePointerHelper +{ + typedef T Type; +}; + +template +struct RemovePointerHelper +{ + typedef Pointee Type; +}; + +} +# 1198 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct RemovePointer + : detail::RemovePointerHelper::Type> +{}; +# 1213 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct AddPointer +{ + typedef typename RemoveReference::Type* Type; +}; +# 1239 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +struct EnableIf +{}; + +template +struct EnableIf +{ + typedef T Type; +}; + + + + + + + +template +struct Conditional +{ + typedef A Type; +}; + +template +struct Conditional +{ + typedef B Type; +}; + +namespace detail { + +template::value, + bool IsFunction = IsFunction::value> +struct DecaySelector; + +template +struct DecaySelector +{ + typedef typename RemoveCV::Type Type; +}; + +template +struct DecaySelector +{ + typedef typename RemoveExtent::Type* Type; +}; + +template +struct DecaySelector +{ + typedef typename AddPointer::Type Type; +}; + +}; +# 1306 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" +template +class Decay + : public detail::DecaySelector::Type> +{ +}; + +} +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IntegerTypeTraits.h" 2 + + +namespace mozilla { + +namespace detail { + + + + + + +template +struct StdintTypeForSizeAndSignedness; + +template<> +struct StdintTypeForSizeAndSignedness<1, true> +{ + typedef int8_t Type; +}; + +template<> +struct StdintTypeForSizeAndSignedness<1, false> +{ + typedef uint8_t Type; +}; + +template<> +struct StdintTypeForSizeAndSignedness<2, true> +{ + typedef int16_t Type; +}; + +template<> +struct StdintTypeForSizeAndSignedness<2, false> +{ + typedef uint16_t Type; +}; + +template<> +struct StdintTypeForSizeAndSignedness<4, true> +{ + typedef int32_t Type; +}; + +template<> +struct StdintTypeForSizeAndSignedness<4, false> +{ + typedef uint32_t Type; +}; + +template<> +struct StdintTypeForSizeAndSignedness<8, true> +{ + typedef int64_t Type; +}; + +template<> +struct StdintTypeForSizeAndSignedness<8, false> +{ + typedef uint64_t Type; +}; + +} + +template +struct UnsignedStdintTypeForSize + : detail::StdintTypeForSizeAndSignedness +{}; + +template +struct SignedStdintTypeForSize + : detail::StdintTypeForSizeAndSignedness +{}; + +template +struct PositionOfSignBit +{ + static_assert(IsIntegral::value, + "PositionOfSignBit is only for integral types"); + + static const size_t value = 8 * sizeof(IntegerType) - 1; +}; + + + + + + +template +struct MinValue +{ +private: + static_assert(IsIntegral::value, + "MinValue is only for integral types"); + + typedef typename MakeUnsigned::Type UnsignedIntegerType; + static const size_t PosOfSignBit = PositionOfSignBit::value; + +public: + + + + + + + static const IntegerType value = + IsSigned::value + ? IntegerType(UnsignedIntegerType(1) << PosOfSignBit) + : IntegerType(0); +}; + + + + + + +template +struct MaxValue +{ + static_assert(IsIntegral::value, + "MaxValue is only for integral types"); + + + + + static const IntegerType value = ~MinValue::value; +}; + +} +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h" 2 + +namespace mozilla { +# 43 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h" +template +class CastableTypedEnumResult +{ +private: + const E mValue; + +public: + explicit constexpr CastableTypedEnumResult(E aValue) + : mValue(aValue) + {} + + constexpr operator E() const { return mValue; } + + template + explicit constexpr + operator DestinationType() const { return DestinationType(mValue); } + + constexpr bool operator !() const { return !bool(mValue); } +}; +# 84 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h" +template constexpr CastableTypedEnumResult operator |(const E& aE, const CastableTypedEnumResult& aR) { return CastableTypedEnumResult(aE | E(aR)); } template constexpr CastableTypedEnumResult operator |(const CastableTypedEnumResult& aR, const E& aE) { return CastableTypedEnumResult(E(aR) | aE); } template constexpr CastableTypedEnumResult operator |(const CastableTypedEnumResult& aR1, const CastableTypedEnumResult& aR2) { return CastableTypedEnumResult(E(aR1) | E(aR2)); } +template constexpr CastableTypedEnumResult operator &(const E& aE, const CastableTypedEnumResult& aR) { return CastableTypedEnumResult(aE & E(aR)); } template constexpr CastableTypedEnumResult operator &(const CastableTypedEnumResult& aR, const E& aE) { return CastableTypedEnumResult(E(aR) & aE); } template constexpr CastableTypedEnumResult operator &(const CastableTypedEnumResult& aR1, const CastableTypedEnumResult& aR2) { return CastableTypedEnumResult(E(aR1) & E(aR2)); } +template constexpr CastableTypedEnumResult operator ^(const E& aE, const CastableTypedEnumResult& aR) { return CastableTypedEnumResult(aE ^ E(aR)); } template constexpr CastableTypedEnumResult operator ^(const CastableTypedEnumResult& aR, const E& aE) { return CastableTypedEnumResult(E(aR) ^ aE); } template constexpr CastableTypedEnumResult operator ^(const CastableTypedEnumResult& aR1, const CastableTypedEnumResult& aR2) { return CastableTypedEnumResult(E(aR1) ^ E(aR2)); } +template constexpr bool operator ==(const E& aE, const CastableTypedEnumResult& aR) { return bool(aE == E(aR)); } template constexpr bool operator ==(const CastableTypedEnumResult& aR, const E& aE) { return bool(E(aR) == aE); } template constexpr bool operator ==(const CastableTypedEnumResult& aR1, const CastableTypedEnumResult& aR2) { return bool(E(aR1) == E(aR2)); } +template constexpr bool operator !=(const E& aE, const CastableTypedEnumResult& aR) { return bool(aE != E(aR)); } template constexpr bool operator !=(const CastableTypedEnumResult& aR, const E& aE) { return bool(E(aR) != aE); } template constexpr bool operator !=(const CastableTypedEnumResult& aR1, const CastableTypedEnumResult& aR2) { return bool(E(aR1) != E(aR2)); } + +template +constexpr CastableTypedEnumResult +operator ~(const CastableTypedEnumResult& aR) +{ + return CastableTypedEnumResult(~(E(aR))); +} +# 106 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h" +template E& operator &=(E& aR1, const CastableTypedEnumResult& aR2) { return aR1 &= E(aR2); } +template E& operator |=(E& aR1, const CastableTypedEnumResult& aR2) { return aR1 |= E(aR2); } +template E& operator ^=(E& aR1, const CastableTypedEnumResult& aR2) { return aR1 ^= E(aR2); } + + + + + +namespace detail { +template +struct UnsignedIntegerTypeForEnum + : UnsignedStdintTypeForSize +{}; +} + +} +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoTypes.h" 2 + + + + + + +struct ServoNodeData; +namespace mozilla { + + + + + +template +struct ServoUnsafeCell { + T value; + + + ServoUnsafeCell() : value() {}; +}; + +template +struct ServoCell { + ServoUnsafeCell value; + T Get() const { return value.value; } + void Set(T arg) { value.value = arg; } + ServoCell() : value() {}; +}; + + + + +enum class LazyComputeBehavior { + Allow, + Assert, +}; + + + + +enum class TraversalRootBehavior { + Normal, + UnstyledChildrenOnly, +}; + + +enum class UpdateAnimationsTasks : uint8_t { + CSSAnimations = 1 << 0, + CSSTransitions = 1 << 1, + EffectProperties = 1 << 2, + CascadeResults = 1 << 3, +}; + +inline constexpr mozilla::CastableTypedEnumResult operator |(UpdateAnimationsTasks a, UpdateAnimationsTasks b) { typedef mozilla::CastableTypedEnumResult Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum::Type U; return Result(UpdateAnimationsTasks(U(a) | U(b))); } inline UpdateAnimationsTasks& operator |=(UpdateAnimationsTasks& a, UpdateAnimationsTasks b) { return a = a | b; } inline constexpr mozilla::CastableTypedEnumResult operator &(UpdateAnimationsTasks a, UpdateAnimationsTasks b) { typedef mozilla::CastableTypedEnumResult Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum::Type U; return Result(UpdateAnimationsTasks(U(a) & U(b))); } inline UpdateAnimationsTasks& operator &=(UpdateAnimationsTasks& a, UpdateAnimationsTasks b) { return a = a & b; } inline constexpr mozilla::CastableTypedEnumResult operator ^(UpdateAnimationsTasks a, UpdateAnimationsTasks b) { typedef mozilla::CastableTypedEnumResult Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum::Type U; return Result(UpdateAnimationsTasks(U(a) ^ U(b))); } inline UpdateAnimationsTasks& operator ^=(UpdateAnimationsTasks& a, UpdateAnimationsTasks b) { return a = a ^ b; } inline constexpr mozilla::CastableTypedEnumResult operator~(UpdateAnimationsTasks a) { typedef mozilla::CastableTypedEnumResult Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum::Type U; return Result(UpdateAnimationsTasks(~(U(a)))); } + +} +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h" 1 +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 1 +# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Likely.h" 1 +# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MacroArgs.h" 1 +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticAnalysisFunctions.h" 1 +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2 + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTraceRefcnt.h" 1 + + + + + + + + +# 1 "/usr/include/stdio.h" 1 3 4 +# 29 "/usr/include/stdio.h" 3 4 +extern "C" { + + + + +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4 +# 34 "/usr/include/stdio.h" 2 3 4 + +# 1 "/usr/include/bits/types.h" 1 3 4 +# 27 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/bits/types.h" 2 3 4 + + +typedef unsigned char __u_char; +typedef unsigned short int __u_short; +typedef unsigned int __u_int; +typedef unsigned long int __u_long; + + +typedef signed char __int8_t; +typedef unsigned char __uint8_t; +typedef signed short int __int16_t; +typedef unsigned short int __uint16_t; +typedef signed int __int32_t; +typedef unsigned int __uint32_t; + +typedef signed long int __int64_t; +typedef unsigned long int __uint64_t; + + + + + + + +typedef long int __quad_t; +typedef unsigned long int __u_quad_t; +# 121 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/typesizes.h" 1 3 4 +# 122 "/usr/include/bits/types.h" 2 3 4 + + +typedef unsigned long int __dev_t; +typedef unsigned int __uid_t; +typedef unsigned int __gid_t; +typedef unsigned long int __ino_t; +typedef unsigned long int __ino64_t; +typedef unsigned int __mode_t; +typedef unsigned long int __nlink_t; +typedef long int __off_t; +typedef long int __off64_t; +typedef int __pid_t; +typedef struct { int __val[2]; } __fsid_t; +typedef long int __clock_t; +typedef unsigned long int __rlim_t; +typedef unsigned long int __rlim64_t; +typedef unsigned int __id_t; +typedef long int __time_t; +typedef unsigned int __useconds_t; +typedef long int __suseconds_t; + +typedef int __daddr_t; +typedef int __key_t; + + +typedef int __clockid_t; + + +typedef void * __timer_t; + + +typedef long int __blksize_t; + + + + +typedef long int __blkcnt_t; +typedef long int __blkcnt64_t; + + +typedef unsigned long int __fsblkcnt_t; +typedef unsigned long int __fsblkcnt64_t; + + +typedef unsigned long int __fsfilcnt_t; +typedef unsigned long int __fsfilcnt64_t; + + +typedef long int __fsword_t; + +typedef long int __ssize_t; + + +typedef long int __syscall_slong_t; + +typedef unsigned long int __syscall_ulong_t; + + + +typedef __off64_t __loff_t; +typedef __quad_t *__qaddr_t; +typedef char *__caddr_t; + + +typedef long int __intptr_t; + + +typedef unsigned int __socklen_t; +# 36 "/usr/include/stdio.h" 2 3 4 +# 74 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/libio.h" 1 3 4 +# 31 "/usr/include/libio.h" 3 4 +# 1 "/usr/include/_G_config.h" 1 3 4 +# 15 "/usr/include/_G_config.h" 3 4 +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4 +# 16 "/usr/include/_G_config.h" 2 3 4 + + + + +# 1 "/usr/include/wchar.h" 1 3 4 +# 21 "/usr/include/_G_config.h" 2 3 4 +typedef struct +{ + __off_t __pos; + __mbstate_t __state; +} _G_fpos_t; +typedef struct +{ + __off64_t __pos; + __mbstate_t __state; +} _G_fpos64_t; +# 32 "/usr/include/libio.h" 2 3 4 +# 144 "/usr/include/libio.h" 3 4 +struct _IO_jump_t; struct _IO_FILE; + + + + + +typedef void _IO_lock_t; + + + + + +struct _IO_marker { + struct _IO_marker *_next; + struct _IO_FILE *_sbuf; + + + + int _pos; +# 173 "/usr/include/libio.h" 3 4 +}; + + +enum __codecvt_result +{ + __codecvt_ok, + __codecvt_partial, + __codecvt_error, + __codecvt_noconv +}; +# 241 "/usr/include/libio.h" 3 4 +struct _IO_FILE { + int _flags; + + + + + char* _IO_read_ptr; + char* _IO_read_end; + char* _IO_read_base; + char* _IO_write_base; + char* _IO_write_ptr; + char* _IO_write_end; + char* _IO_buf_base; + char* _IO_buf_end; + + char *_IO_save_base; + char *_IO_backup_base; + char *_IO_save_end; + + struct _IO_marker *_markers; + + struct _IO_FILE *_chain; + + int _fileno; + + + + int _flags2; + + __off_t _old_offset; + + + + unsigned short _cur_column; + signed char _vtable_offset; + char _shortbuf[1]; + + + + _IO_lock_t *_lock; +# 289 "/usr/include/libio.h" 3 4 + __off64_t _offset; + + + + + + + + void *__pad1; + void *__pad2; + void *__pad3; + void *__pad4; + + size_t __pad5; + int _mode; + + char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)]; + +}; + + + + + +struct _IO_FILE_plus; + +extern struct _IO_FILE_plus _IO_2_1_stdin_; +extern struct _IO_FILE_plus _IO_2_1_stdout_; +extern struct _IO_FILE_plus _IO_2_1_stderr_; +# 333 "/usr/include/libio.h" 3 4 +typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes); + + + + + + + +typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf, + size_t __n); + + + + + + + +typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w); + + +typedef int __io_close_fn (void *__cookie); + + + + +typedef __io_read_fn cookie_read_function_t; +typedef __io_write_fn cookie_write_function_t; +typedef __io_seek_fn cookie_seek_function_t; +typedef __io_close_fn cookie_close_function_t; + + +typedef struct +{ + __io_read_fn *read; + __io_write_fn *write; + __io_seek_fn *seek; + __io_close_fn *close; +} _IO_cookie_io_functions_t; +typedef _IO_cookie_io_functions_t cookie_io_functions_t; + +struct _IO_cookie_file; + + +extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write, + void *__cookie, _IO_cookie_io_functions_t __fns); + + + + +extern "C" { + + +extern int __underflow (_IO_FILE *); +extern int __uflow (_IO_FILE *); +extern int __overflow (_IO_FILE *, int); +# 429 "/usr/include/libio.h" 3 4 +extern int _IO_getc (_IO_FILE *__fp); +extern int _IO_putc (int __c, _IO_FILE *__fp); +extern int _IO_feof (_IO_FILE *__fp) throw (); +extern int _IO_ferror (_IO_FILE *__fp) throw (); + +extern int _IO_peekc_locked (_IO_FILE *__fp); + + + + + +extern void _IO_flockfile (_IO_FILE *) throw (); +extern void _IO_funlockfile (_IO_FILE *) throw (); +extern int _IO_ftrylockfile (_IO_FILE *) throw (); +# 459 "/usr/include/libio.h" 3 4 +extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict, + __gnuc_va_list, int *__restrict); +extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict, + __gnuc_va_list); +extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t); +extern size_t _IO_sgetn (_IO_FILE *, void *, size_t); + +extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int); +extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int); + +extern void _IO_free_backup_area (_IO_FILE *) throw (); +# 521 "/usr/include/libio.h" 3 4 +} +# 75 "/usr/include/stdio.h" 2 3 4 + + + + +typedef __gnuc_va_list va_list; +# 90 "/usr/include/stdio.h" 3 4 +typedef __off_t off_t; + + + + + + +typedef __off64_t off64_t; + + + + + + +typedef __ssize_t ssize_t; + + + + + + + +typedef _G_fpos_t fpos_t; + + + + + +typedef _G_fpos64_t fpos64_t; +# 166 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/bits/stdio_lim.h" 1 3 4 +# 167 "/usr/include/stdio.h" 2 3 4 + + + +extern struct _IO_FILE *stdin; +extern struct _IO_FILE *stdout; +extern struct _IO_FILE *stderr; + + + + + + + +extern int remove (const char *__filename) throw (); + +extern int rename (const char *__old, const char *__new) throw (); + + + + +extern int renameat (int __oldfd, const char *__old, int __newfd, + const char *__new) throw (); +# 197 "/usr/include/stdio.h" 3 4 +extern FILE *tmpfile (void) ; +# 207 "/usr/include/stdio.h" 3 4 +extern FILE *tmpfile64 (void) ; + + + +extern char *tmpnam (char *__s) throw () ; + + + + + +extern char *tmpnam_r (char *__s) throw () ; +# 229 "/usr/include/stdio.h" 3 4 +extern char *tempnam (const char *__dir, const char *__pfx) + throw () __attribute__ ((__malloc__)) ; +# 239 "/usr/include/stdio.h" 3 4 +extern int fclose (FILE *__stream); + + + + +extern int fflush (FILE *__stream); +# 254 "/usr/include/stdio.h" 3 4 +extern int fflush_unlocked (FILE *__stream); +# 264 "/usr/include/stdio.h" 3 4 +extern int fcloseall (void); +# 274 "/usr/include/stdio.h" 3 4 +extern FILE *fopen (const char *__restrict __filename, + const char *__restrict __modes) ; + + + + +extern FILE *freopen (const char *__restrict __filename, + const char *__restrict __modes, + FILE *__restrict __stream) ; +# 299 "/usr/include/stdio.h" 3 4 +extern FILE *fopen64 (const char *__restrict __filename, + const char *__restrict __modes) ; +extern FILE *freopen64 (const char *__restrict __filename, + const char *__restrict __modes, + FILE *__restrict __stream) ; + + + + +extern FILE *fdopen (int __fd, const char *__modes) throw () ; + + + + + +extern FILE *fopencookie (void *__restrict __magic_cookie, + const char *__restrict __modes, + _IO_cookie_io_functions_t __io_funcs) throw () ; + + + + +extern FILE *fmemopen (void *__s, size_t __len, const char *__modes) + throw () ; + + + + +extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ; + + + + + + +extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw (); + + + +extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, + int __modes, size_t __n) throw (); + + + + + +extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf, + size_t __size) throw (); + + +extern void setlinebuf (FILE *__stream) throw (); +# 358 "/usr/include/stdio.h" 3 4 +extern int fprintf (FILE *__restrict __stream, + const char *__restrict __format, ...); + + + + +extern int printf (const char *__restrict __format, ...); + +extern int sprintf (char *__restrict __s, + const char *__restrict __format, ...) throw (); + + + + + +extern int vfprintf (FILE *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg); + + + + +extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg); + +extern int vsprintf (char *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg) throw (); + + + + + +extern int snprintf (char *__restrict __s, size_t __maxlen, + const char *__restrict __format, ...) + throw () __attribute__ ((__format__ (__printf__, 3, 4))); + +extern int vsnprintf (char *__restrict __s, size_t __maxlen, + const char *__restrict __format, __gnuc_va_list __arg) + throw () __attribute__ ((__format__ (__printf__, 3, 0))); + + + + + + +extern int vasprintf (char **__restrict __ptr, const char *__restrict __f, + __gnuc_va_list __arg) + throw () __attribute__ ((__format__ (__printf__, 2, 0))) ; +extern int __asprintf (char **__restrict __ptr, + const char *__restrict __fmt, ...) + throw () __attribute__ ((__format__ (__printf__, 2, 3))) ; +extern int asprintf (char **__restrict __ptr, + const char *__restrict __fmt, ...) + throw () __attribute__ ((__format__ (__printf__, 2, 3))) ; + + + + +extern int vdprintf (int __fd, const char *__restrict __fmt, + __gnuc_va_list __arg) + __attribute__ ((__format__ (__printf__, 2, 0))); +extern int dprintf (int __fd, const char *__restrict __fmt, ...) + __attribute__ ((__format__ (__printf__, 2, 3))); +# 427 "/usr/include/stdio.h" 3 4 +extern int fscanf (FILE *__restrict __stream, + const char *__restrict __format, ...) ; + + + + +extern int scanf (const char *__restrict __format, ...) ; + +extern int sscanf (const char *__restrict __s, + const char *__restrict __format, ...) throw (); +# 473 "/usr/include/stdio.h" 3 4 +extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg) + __attribute__ ((__format__ (__scanf__, 2, 0))) ; + + + + + +extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) + __attribute__ ((__format__ (__scanf__, 1, 0))) ; + + +extern int vsscanf (const char *__restrict __s, + const char *__restrict __format, __gnuc_va_list __arg) + throw () __attribute__ ((__format__ (__scanf__, 2, 0))); +# 533 "/usr/include/stdio.h" 3 4 +extern int fgetc (FILE *__stream); +extern int getc (FILE *__stream); + + + + + +extern int getchar (void); +# 552 "/usr/include/stdio.h" 3 4 +extern int getc_unlocked (FILE *__stream); +extern int getchar_unlocked (void); +# 563 "/usr/include/stdio.h" 3 4 +extern int fgetc_unlocked (FILE *__stream); +# 575 "/usr/include/stdio.h" 3 4 +extern int fputc (int __c, FILE *__stream); +extern int putc (int __c, FILE *__stream); + + + + + +extern int putchar (int __c); +# 596 "/usr/include/stdio.h" 3 4 +extern int fputc_unlocked (int __c, FILE *__stream); + + + + + + + +extern int putc_unlocked (int __c, FILE *__stream); +extern int putchar_unlocked (int __c); + + + + + + +extern int getw (FILE *__stream); + + +extern int putw (int __w, FILE *__stream); +# 624 "/usr/include/stdio.h" 3 4 +extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream) + ; +# 651 "/usr/include/stdio.h" 3 4 +extern char *fgets_unlocked (char *__restrict __s, int __n, + FILE *__restrict __stream) ; +# 667 "/usr/include/stdio.h" 3 4 +extern __ssize_t __getdelim (char **__restrict __lineptr, + size_t *__restrict __n, int __delimiter, + FILE *__restrict __stream) ; +extern __ssize_t getdelim (char **__restrict __lineptr, + size_t *__restrict __n, int __delimiter, + FILE *__restrict __stream) ; + + + + + + + +extern __ssize_t getline (char **__restrict __lineptr, + size_t *__restrict __n, + FILE *__restrict __stream) ; +# 691 "/usr/include/stdio.h" 3 4 +extern int fputs (const char *__restrict __s, FILE *__restrict __stream); + + + + + +extern int puts (const char *__s); + + + + + + +extern int ungetc (int __c, FILE *__stream); + + + + + + +extern size_t fread (void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream) ; + + + + +extern size_t fwrite (const void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __s); +# 728 "/usr/include/stdio.h" 3 4 +extern int fputs_unlocked (const char *__restrict __s, + FILE *__restrict __stream); +# 739 "/usr/include/stdio.h" 3 4 +extern size_t fread_unlocked (void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream) ; +extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream); +# 751 "/usr/include/stdio.h" 3 4 +extern int fseek (FILE *__stream, long int __off, int __whence); + + + + +extern long int ftell (FILE *__stream) ; + + + + +extern void rewind (FILE *__stream); +# 775 "/usr/include/stdio.h" 3 4 +extern int fseeko (FILE *__stream, __off_t __off, int __whence); + + + + +extern __off_t ftello (FILE *__stream) ; +# 800 "/usr/include/stdio.h" 3 4 +extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos); + + + + +extern int fsetpos (FILE *__stream, const fpos_t *__pos); +# 820 "/usr/include/stdio.h" 3 4 +extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence); +extern __off64_t ftello64 (FILE *__stream) ; +extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos); +extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos); + + + + +extern void clearerr (FILE *__stream) throw (); + +extern int feof (FILE *__stream) throw () ; + +extern int ferror (FILE *__stream) throw () ; + + + + +extern void clearerr_unlocked (FILE *__stream) throw (); +extern int feof_unlocked (FILE *__stream) throw () ; +extern int ferror_unlocked (FILE *__stream) throw () ; +# 848 "/usr/include/stdio.h" 3 4 +extern void perror (const char *__s); + + + + + + + +# 1 "/usr/include/bits/sys_errlist.h" 1 3 4 +# 26 "/usr/include/bits/sys_errlist.h" 3 4 +extern int sys_nerr; +extern const char *const sys_errlist[]; + + +extern int _sys_nerr; +extern const char *const _sys_errlist[]; +# 856 "/usr/include/stdio.h" 2 3 4 + + + + +extern int fileno (FILE *__stream) throw () ; + + + + +extern int fileno_unlocked (FILE *__stream) throw () ; +# 874 "/usr/include/stdio.h" 3 4 +extern FILE *popen (const char *__command, const char *__modes) ; + + + + + +extern int pclose (FILE *__stream); + + + + + +extern char *ctermid (char *__s) throw (); + + + + + +extern char *cuserid (char *__s); + + + + +struct obstack; + + +extern int obstack_printf (struct obstack *__restrict __obstack, + const char *__restrict __format, ...) + throw () __attribute__ ((__format__ (__printf__, 2, 3))); +extern int obstack_vprintf (struct obstack *__restrict __obstack, + const char *__restrict __format, + __gnuc_va_list __args) + throw () __attribute__ ((__format__ (__printf__, 2, 0))); + + + + + + + +extern void flockfile (FILE *__stream) throw (); + + + +extern int ftrylockfile (FILE *__stream) throw () ; + + +extern void funlockfile (FILE *__stream) throw (); +# 944 "/usr/include/stdio.h" 3 4 +} +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTraceRefcnt.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h" 1 +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcom-config.h" 1 +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h" 2 + + + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 1 +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/new" 1 3 +# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/new" 3 + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 1 3 +# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 3 + +#pragma GCC visibility push(default) + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_lockfree_defines.h" 1 3 +# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_lockfree_defines.h" 3 +# 39 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 2 3 + +extern "C++" { + +namespace std +{ +# 60 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 3 + class exception + { + public: + exception() noexcept { } + virtual ~exception() noexcept; + + + + virtual const char* + what() const noexcept; + }; + + + + class bad_exception : public exception + { + public: + bad_exception() noexcept { } + + + + virtual ~bad_exception() noexcept; + + + virtual const char* + what() const noexcept; + }; + + + typedef void (*terminate_handler) (); + + + typedef void (*unexpected_handler) (); + + + terminate_handler set_terminate(terminate_handler) noexcept; + + + + terminate_handler get_terminate() noexcept; + + + + + void terminate() noexcept __attribute__ ((__noreturn__)); + + + unexpected_handler set_unexpected(unexpected_handler) noexcept; + + + + unexpected_handler get_unexpected() noexcept; + + + + + void unexpected() __attribute__ ((__noreturn__)); +# 129 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 3 + bool uncaught_exception() noexcept __attribute__ ((__pure__)); +# 138 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 3 +} + +namespace __gnu_cxx +{ +# 160 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 3 + void __verbose_terminate_handler(); + + +} + +} + +#pragma GCC visibility pop + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/exception_ptr.h" 1 3 +# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/exception_ptr.h" 3 +#pragma GCC visibility push(default) + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/exception_defines.h" 1 3 +# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/exception_ptr.h" 2 3 + + + + + +extern "C++" { + +namespace std +{ + class type_info; + + + + + + namespace __exception_ptr + { + class exception_ptr; + } + + using __exception_ptr::exception_ptr; + + + + + + exception_ptr current_exception() noexcept; + + + void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__)); + + namespace __exception_ptr + { + using std::rethrow_exception; + + + + + + class exception_ptr + { + void* _M_exception_object; + + explicit exception_ptr(void* __e) noexcept; + + void _M_addref() noexcept; + void _M_release() noexcept; + + void *_M_get() const noexcept __attribute__ ((__pure__)); + + friend exception_ptr std::current_exception() noexcept; + friend void std::rethrow_exception(exception_ptr); + + public: + exception_ptr() noexcept; + + exception_ptr(const exception_ptr&) noexcept; + + + exception_ptr(nullptr_t) noexcept + : _M_exception_object(0) + { } + + exception_ptr(exception_ptr&& __o) noexcept + : _M_exception_object(__o._M_exception_object) + { __o._M_exception_object = 0; } +# 113 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/exception_ptr.h" 3 + exception_ptr& + operator=(const exception_ptr&) noexcept; + + + exception_ptr& + operator=(exception_ptr&& __o) noexcept + { + exception_ptr(static_cast(__o)).swap(*this); + return *this; + } + + + ~exception_ptr() noexcept; + + void + swap(exception_ptr&) noexcept; +# 140 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/exception_ptr.h" 3 + explicit operator bool() const + { return _M_exception_object; } + + + friend bool + operator==(const exception_ptr&, const exception_ptr&) + noexcept __attribute__ ((__pure__)); + + const class std::type_info* + __cxa_exception_type() const noexcept + __attribute__ ((__pure__)); + }; + + bool + operator==(const exception_ptr&, const exception_ptr&) + noexcept __attribute__ ((__pure__)); + + bool + operator!=(const exception_ptr&, const exception_ptr&) + noexcept __attribute__ ((__pure__)); + + inline void + swap(exception_ptr& __lhs, exception_ptr& __rhs) + { __lhs.swap(__rhs); } + + } + + + + template + exception_ptr + make_exception_ptr(_Ex __ex) noexcept + { + + try + { + throw __ex; + } + catch(...) + { + return current_exception(); + } + + + + } + + + + + + template + exception_ptr + copy_exception(_Ex __ex) noexcept __attribute__ ((__deprecated__)); + + template + exception_ptr + copy_exception(_Ex __ex) noexcept + { return std::make_exception_ptr<_Ex>(__ex); } + + +} + +} + +#pragma GCC visibility pop +# 171 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/nested_exception.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/nested_exception.h" 3 +#pragma GCC visibility push(default) + + + + + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 1 3 +# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/concept_check.h" 1 3 +# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/concept_check.h" 3 +# 35 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + inline _Tp* + __addressof(_Tp& __r) noexcept + { + return reinterpret_cast<_Tp*> + (&const_cast(reinterpret_cast(__r))); + } + + +} + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 1 3 +# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3 +# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3 +namespace std +{ + typedef unsigned short uint_least16_t; + typedef unsigned int uint_least32_t; +} + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 68 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3 + template + struct integral_constant + { + static constexpr _Tp value = __v; + typedef _Tp value_type; + typedef integral_constant<_Tp, __v> type; + constexpr operator value_type() const { return value; } + + + + + constexpr value_type operator()() const { return value; } + + }; + + template + constexpr _Tp integral_constant<_Tp, __v>::value; + + + typedef integral_constant true_type; + + + typedef integral_constant false_type; + + template + using __bool_constant = integral_constant; +# 103 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3 + template + struct conditional; + + template + struct __or_; + + template<> + struct __or_<> + : public false_type + { }; + + template + struct __or_<_B1> + : public _B1 + { }; + + template + struct __or_<_B1, _B2> + : public conditional<_B1::value, _B1, _B2>::type + { }; + + template + struct __or_<_B1, _B2, _B3, _Bn...> + : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type + { }; + + template + struct __and_; + + template<> + struct __and_<> + : public true_type + { }; + + template + struct __and_<_B1> + : public _B1 + { }; + + template + struct __and_<_B1, _B2> + : public conditional<_B1::value, _B2, _B1>::type + { }; + + template + struct __and_<_B1, _B2, _B3, _Bn...> + : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type + { }; + + template + struct __not_ + : public integral_constant + { }; + + struct __nonesuch { + __nonesuch() = delete; + ~__nonesuch() = delete; + __nonesuch(__nonesuch const&) = delete; + void operator=(__nonesuch const&) = delete; + }; +# 189 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3 + template + struct __success_type + { typedef _Tp type; }; + + struct __failure_type + { }; + + + + template + struct remove_cv; + + template + struct __is_void_helper + : public false_type { }; + + template<> + struct __is_void_helper + : public true_type { }; + + + template + struct is_void + : public __is_void_helper::type>::type + { }; + + template + struct __is_integral_helper + : public false_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + + template<> + struct __is_integral_helper + : public true_type { }; + + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; +# 321 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3 + template + struct is_integral + : public __is_integral_helper::type>::type + { }; + + template + struct __is_floating_point_helper + : public false_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; +# 349 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3 + template + struct is_floating_point + : public __is_floating_point_helper::type>::type + { }; + + + template + struct is_array + : public false_type { }; + + template + struct is_array<_Tp[_Size]> + : public true_type { }; + + template + struct is_array<_Tp[]> + : public true_type { }; + + template + struct __is_pointer_helper + : public false_type { }; + + template + struct __is_pointer_helper<_Tp*> + : public true_type { }; + + + template + struct is_pointer + : public __is_pointer_helper::type>::type + { }; + + + template + struct is_lvalue_reference + : public false_type { }; + + template + struct is_lvalue_reference<_Tp&> + : public true_type { }; + + + template + struct is_rvalue_reference + : public false_type { }; + + template + struct is_rvalue_reference<_Tp&&> + : public true_type { }; + + template + struct is_function; + + template + struct __is_member_object_pointer_helper + : public false_type { }; + + template + struct __is_member_object_pointer_helper<_Tp _Cp::*> + : public integral_constant::value> { }; + + + template + struct is_member_object_pointer + : public __is_member_object_pointer_helper< + typename remove_cv<_Tp>::type>::type + { }; + + template + struct __is_member_function_pointer_helper + : public false_type { }; + + template + struct __is_member_function_pointer_helper<_Tp _Cp::*> + : public integral_constant::value> { }; + + + template + struct is_member_function_pointer + : public __is_member_function_pointer_helper< + typename remove_cv<_Tp>::type>::type + { }; + + + template + struct is_enum + : public integral_constant + { }; + + + template + struct is_union + : public integral_constant + { }; + + + template + struct is_class + : public integral_constant + { }; + + + template + struct is_function + : public false_type { }; + + template + struct is_function<_Res(_ArgTypes...)> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) &> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) &&> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......)> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) &> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) &&> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) const> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) const &> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) const &&> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) const> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) const &> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) const &&> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) volatile> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) volatile &> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) volatile &&> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) volatile> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) volatile &> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) volatile &&> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) const volatile> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) const volatile &> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) const volatile &&> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) const volatile> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) const volatile &> + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) const volatile &&> + : public true_type { }; + + + + template + struct __is_null_pointer_helper + : public false_type { }; + + template<> + struct __is_null_pointer_helper + : public true_type { }; + + + template + struct is_null_pointer + : public __is_null_pointer_helper::type>::type + { }; + + + template + struct __is_nullptr_t + : public is_null_pointer<_Tp> + { }; + + + + + template + struct is_reference + : public __or_, + is_rvalue_reference<_Tp>>::type + { }; + + + template + struct is_arithmetic + : public __or_, is_floating_point<_Tp>>::type + { }; + + + template + struct is_fundamental + : public __or_, is_void<_Tp>, + is_null_pointer<_Tp>>::type + { }; + + + template + struct is_object + : public __not_<__or_, is_reference<_Tp>, + is_void<_Tp>>>::type + { }; + + template + struct is_member_pointer; + + + template + struct is_scalar + : public __or_, is_enum<_Tp>, is_pointer<_Tp>, + is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type + { }; + + + template + struct is_compound + : public integral_constant::value> { }; + + template + struct __is_member_pointer_helper + : public false_type { }; + + template + struct __is_member_pointer_helper<_Tp _Cp::*> + : public true_type { }; + + + template + struct is_member_pointer + : public __is_member_pointer_helper::type>::type + { }; + + + + template + struct __is_referenceable + : public __or_, is_reference<_Tp>>::type + { }; + + template + struct __is_referenceable<_Res(_Args...)> + : public true_type + { }; + + template + struct __is_referenceable<_Res(_Args......)> + : public true_type + { }; + + + + + template + struct is_const + : public false_type { }; + + template + struct is_const<_Tp const> + : public true_type { }; + + + template + struct is_volatile + : public false_type { }; + + template + struct is_volatile<_Tp volatile> + : public true_type { }; + + + template + struct is_trivial + : public integral_constant + { }; + + + template + struct is_trivially_copyable + : public integral_constant + { }; + + + template + struct is_standard_layout + : public integral_constant + { }; + + + + template + struct is_pod + : public integral_constant + { }; + + + template + struct is_literal_type + : public integral_constant + { }; + + + template + struct is_empty + : public integral_constant + { }; + + + template + struct is_polymorphic + : public integral_constant + { }; + + + + + template + struct is_final + : public integral_constant + { }; + + + + template + struct is_abstract + : public integral_constant + { }; + + template::value> + struct __is_signed_helper + : public false_type { }; + + template + struct __is_signed_helper<_Tp, true> + : public integral_constant + { }; + + + template + struct is_signed + : public __is_signed_helper<_Tp>::type + { }; + + + template + struct is_unsigned + : public __and_, __not_>> + { }; + + + + + template + struct add_rvalue_reference; + + + + + + template + typename add_rvalue_reference<_Tp>::type declval() noexcept; + + template + struct extent; + + template + struct remove_all_extents; + + template + struct __is_array_known_bounds + : public integral_constant::value > 0)> + { }; + + template + struct __is_array_unknown_bounds + : public __and_, __not_>> + { }; + + + + + + + struct __do_is_destructible_impl + { + template().~_Tp())> + static true_type __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_destructible_impl + : public __do_is_destructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_destructible_safe; + + template + struct __is_destructible_safe<_Tp, false, false> + : public __is_destructible_impl::type>::type + { }; + + template + struct __is_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_destructible_safe<_Tp, false, true> + : public true_type { }; + + + template + struct is_destructible + : public __is_destructible_safe<_Tp>::type + { }; + + + + + + struct __do_is_nt_destructible_impl + { + template + static integral_constant().~_Tp())> + __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_nt_destructible_impl + : public __do_is_nt_destructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_nt_destructible_safe; + + template + struct __is_nt_destructible_safe<_Tp, false, false> + : public __is_nt_destructible_impl::type>::type + { }; + + template + struct __is_nt_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_nt_destructible_safe<_Tp, false, true> + : public true_type { }; + + + template + struct is_nothrow_destructible + : public __is_nt_destructible_safe<_Tp>::type + { }; + + struct __do_is_default_constructible_impl + { + template + static true_type __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_default_constructible_impl + : public __do_is_default_constructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_default_constructible_atom + : public __and_<__not_>, + __is_default_constructible_impl<_Tp>> + { }; + + template::value> + struct __is_default_constructible_safe; + + + + + + + template + struct __is_default_constructible_safe<_Tp, true> + : public __and_<__is_array_known_bounds<_Tp>, + __is_default_constructible_atom::type>> + { }; + + template + struct __is_default_constructible_safe<_Tp, false> + : public __is_default_constructible_atom<_Tp>::type + { }; + + + template + struct is_default_constructible + : public __is_default_constructible_safe<_Tp>::type + { }; +# 933 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3 + struct __do_is_static_castable_impl + { + template(declval<_From>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_static_castable_impl + : public __do_is_static_castable_impl + { + typedef decltype(__test<_From, _To>(0)) type; + }; + + template + struct __is_static_castable_safe + : public __is_static_castable_impl<_From, _To>::type + { }; + + + template + struct __is_static_castable + : public integral_constant::value)> + { }; + + + + + + + struct __do_is_direct_constructible_impl + { + template()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_direct_constructible_impl + : public __do_is_direct_constructible_impl + { + typedef decltype(__test<_Tp, _Arg>(0)) type; + }; + + template + struct __is_direct_constructible_new_safe + : public __and_, + __is_direct_constructible_impl<_Tp, _Arg>> + { }; + + template + struct is_same; + + template + struct is_base_of; + + template + struct remove_reference; + + template, + is_function<_From>>>::value> + struct __is_base_to_derived_ref; + + template + struct is_constructible; + + + + template + struct __is_base_to_derived_ref<_From, _To, true> + { + typedef typename remove_cv::type>::type __src_t; + typedef typename remove_cv::type>::type __dst_t; + typedef __and_<__not_>, + is_base_of<__src_t, __dst_t>, + __not_>> type; + static constexpr bool value = type::value; + }; + + template + struct __is_base_to_derived_ref<_From, _To, false> + : public false_type + { }; + + template, + is_rvalue_reference<_To>>::value> + struct __is_lvalue_to_rvalue_ref; + + + + template + struct __is_lvalue_to_rvalue_ref<_From, _To, true> + { + typedef typename remove_cv::type>::type __src_t; + typedef typename remove_cv::type>::type __dst_t; + typedef __and_<__not_>, + __or_, + is_base_of<__dst_t, __src_t>>> type; + static constexpr bool value = type::value; + }; + + template + struct __is_lvalue_to_rvalue_ref<_From, _To, false> + : public false_type + { }; + + + + + + + + template + struct __is_direct_constructible_ref_cast + : public __and_<__is_static_castable<_Arg, _Tp>, + __not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>, + __is_lvalue_to_rvalue_ref<_Arg, _Tp> + >>> + { }; + + template + struct __is_direct_constructible_new + : public conditional::value, + __is_direct_constructible_ref_cast<_Tp, _Arg>, + __is_direct_constructible_new_safe<_Tp, _Arg> + >::type + { }; + + template + struct __is_direct_constructible + : public __is_direct_constructible_new<_Tp, _Arg>::type + { }; + + + + + + + struct __do_is_nary_constructible_impl + { + template()...))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_nary_constructible_impl + : public __do_is_nary_constructible_impl + { + typedef decltype(__test<_Tp, _Args...>(0)) type; + }; + + template + struct __is_nary_constructible + : public __is_nary_constructible_impl<_Tp, _Args...>::type + { + static_assert(sizeof...(_Args) > 1, + "Only useful for > 1 arguments"); + }; + + template + struct __is_constructible_impl + : public __is_nary_constructible<_Tp, _Args...> + { }; + + template + struct __is_constructible_impl<_Tp, _Arg> + : public __is_direct_constructible<_Tp, _Arg> + { }; + + template + struct __is_constructible_impl<_Tp> + : public is_default_constructible<_Tp> + { }; + + + template + struct is_constructible + : public __is_constructible_impl<_Tp, _Args...>::type + { }; + + template::value> + struct __is_copy_constructible_impl; + + template + struct __is_copy_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_copy_constructible_impl<_Tp, true> + : public is_constructible<_Tp, const _Tp&> + { }; + + + template + struct is_copy_constructible + : public __is_copy_constructible_impl<_Tp> + { }; + + template::value> + struct __is_move_constructible_impl; + + template + struct __is_move_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_move_constructible_impl<_Tp, true> + : public is_constructible<_Tp, _Tp&&> + { }; + + + template + struct is_move_constructible + : public __is_move_constructible_impl<_Tp> + { }; + + template + struct __is_nt_default_constructible_atom + : public integral_constant + { }; + + template::value> + struct __is_nt_default_constructible_impl; + + template + struct __is_nt_default_constructible_impl<_Tp, true> + : public __and_<__is_array_known_bounds<_Tp>, + __is_nt_default_constructible_atom::type>> + { }; + + template + struct __is_nt_default_constructible_impl<_Tp, false> + : public __is_nt_default_constructible_atom<_Tp> + { }; + + + template + struct is_nothrow_default_constructible + : public __and_, + __is_nt_default_constructible_impl<_Tp>> + { }; + + template + struct __is_nt_constructible_impl + : public integral_constant()...))> + { }; + + template + struct __is_nt_constructible_impl<_Tp, _Arg> + : public integral_constant(declval<_Arg>()))> + { }; + + template + struct __is_nt_constructible_impl<_Tp> + : public is_nothrow_default_constructible<_Tp> + { }; + + + template + struct is_nothrow_constructible + : public __and_, + __is_nt_constructible_impl<_Tp, _Args...>> + { }; + + template::value> + struct __is_nothrow_copy_constructible_impl; + + template + struct __is_nothrow_copy_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_nothrow_copy_constructible_impl<_Tp, true> + : public is_nothrow_constructible<_Tp, const _Tp&> + { }; + + + template + struct is_nothrow_copy_constructible + : public __is_nothrow_copy_constructible_impl<_Tp> + { }; + + template::value> + struct __is_nothrow_move_constructible_impl; + + template + struct __is_nothrow_move_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_nothrow_move_constructible_impl<_Tp, true> + : public is_nothrow_constructible<_Tp, _Tp&&> + { }; + + + template + struct is_nothrow_move_constructible + : public __is_nothrow_move_constructible_impl<_Tp> + { }; + + template + class __is_assignable_helper + { + template() = declval<_Up1>())> + static true_type + __test(int); + + template + static false_type + __test(...); + + public: + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct is_assignable + : public __is_assignable_helper<_Tp, _Up>::type + { }; + + template::value> + struct __is_copy_assignable_impl; + + template + struct __is_copy_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_copy_assignable_impl<_Tp, true> + : public is_assignable<_Tp&, const _Tp&> + { }; + + + template + struct is_copy_assignable + : public __is_copy_assignable_impl<_Tp> + { }; + + template::value> + struct __is_move_assignable_impl; + + template + struct __is_move_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_move_assignable_impl<_Tp, true> + : public is_assignable<_Tp&, _Tp&&> + { }; + + + template + struct is_move_assignable + : public __is_move_assignable_impl<_Tp> + { }; + + template + struct __is_nt_assignable_impl + : public integral_constant() = declval<_Up>())> + { }; + + + template + struct is_nothrow_assignable + : public __and_, + __is_nt_assignable_impl<_Tp, _Up>> + { }; + + template::value> + struct __is_nt_copy_assignable_impl; + + template + struct __is_nt_copy_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_nt_copy_assignable_impl<_Tp, true> + : public is_nothrow_assignable<_Tp&, const _Tp&> + { }; + + + template + struct is_nothrow_copy_assignable + : public __is_nt_copy_assignable_impl<_Tp> + { }; + + template::value> + struct __is_nt_move_assignable_impl; + + template + struct __is_nt_move_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_nt_move_assignable_impl<_Tp, true> + : public is_nothrow_assignable<_Tp&, _Tp&&> + { }; + + + template + struct is_nothrow_move_assignable + : public __is_nt_move_assignable_impl<_Tp> + { }; + + + template + struct is_trivially_constructible + : public __and_, integral_constant> + { }; + + + template + struct is_trivially_default_constructible + : public is_trivially_constructible<_Tp>::type + { }; + + struct __do_is_implicitly_default_constructible_impl + { + template + static void __helper(const _Tp&); + + template + static true_type __test(const _Tp&, + decltype(__helper({}))* = 0); + + static false_type __test(...); + }; + + template + struct __is_implicitly_default_constructible_impl + : public __do_is_implicitly_default_constructible_impl + { + typedef decltype(__test(declval<_Tp>())) type; + }; + + template + struct __is_implicitly_default_constructible_safe + : public __is_implicitly_default_constructible_impl<_Tp>::type + { }; + + template + struct __is_implicitly_default_constructible + : public __and_, + __is_implicitly_default_constructible_safe<_Tp>> + { }; + + + template + struct is_trivially_copy_constructible + : public __and_, + integral_constant> + { }; + + + template + struct is_trivially_move_constructible + : public __and_, + integral_constant> + { }; + + + template + struct is_trivially_assignable + : public __and_, + integral_constant> + { }; + + + template + struct is_trivially_copy_assignable + : public __and_, + integral_constant> + { }; + + + template + struct is_trivially_move_assignable + : public __and_, + integral_constant> + { }; + + + template + struct is_trivially_destructible + : public __and_, integral_constant> + { }; + + + template + struct has_trivial_default_constructor + : public integral_constant + { } __attribute__ ((__deprecated__)); + + + template + struct has_trivial_copy_constructor + : public integral_constant + { } __attribute__ ((__deprecated__)); + + + template + struct has_trivial_copy_assign + : public integral_constant + { } __attribute__ ((__deprecated__)); + + + template + struct has_virtual_destructor + : public integral_constant + { }; + + + + + + template + struct alignment_of + : public integral_constant { }; + + + template + struct rank + : public integral_constant { }; + + template + struct rank<_Tp[_Size]> + : public integral_constant::value> { }; + + template + struct rank<_Tp[]> + : public integral_constant::value> { }; + + + template + struct extent + : public integral_constant { }; + + template + struct extent<_Tp[_Size], _Uint> + : public integral_constant::value> + { }; + + template + struct extent<_Tp[], _Uint> + : public integral_constant::value> + { }; + + + + + + template + struct is_same + : public false_type { }; + + template + struct is_same<_Tp, _Tp> + : public true_type { }; + + + template + struct is_base_of + : public integral_constant + { }; + + template, is_function<_To>, + is_array<_To>>::value> + struct __is_convertible_helper + { typedef typename is_void<_To>::type type; }; + + template + class __is_convertible_helper<_From, _To, false> + { + template + static void __test_aux(_To1); + + template(std::declval<_From1>()))> + static true_type + __test(int); + + template + static false_type + __test(...); + + public: + typedef decltype(__test<_From, _To>(0)) type; + }; + + + + template + struct is_convertible + : public __is_convertible_helper<_From, _To>::type + { }; + + + + + + template + struct remove_const + { typedef _Tp type; }; + + template + struct remove_const<_Tp const> + { typedef _Tp type; }; + + + template + struct remove_volatile + { typedef _Tp type; }; + + template + struct remove_volatile<_Tp volatile> + { typedef _Tp type; }; + + + template + struct remove_cv + { + typedef typename + remove_const::type>::type type; + }; + + + template + struct add_const + { typedef _Tp const type; }; + + + template + struct add_volatile + { typedef _Tp volatile type; }; + + + template + struct add_cv + { + typedef typename + add_const::type>::type type; + }; + + + + + + + template + using remove_const_t = typename remove_const<_Tp>::type; + + + template + using remove_volatile_t = typename remove_volatile<_Tp>::type; + + + template + using remove_cv_t = typename remove_cv<_Tp>::type; + + + template + using add_const_t = typename add_const<_Tp>::type; + + + template + using add_volatile_t = typename add_volatile<_Tp>::type; + + + template + using add_cv_t = typename add_cv<_Tp>::type; + + + + + + template + struct remove_reference + { typedef _Tp type; }; + + template + struct remove_reference<_Tp&> + { typedef _Tp type; }; + + template + struct remove_reference<_Tp&&> + { typedef _Tp type; }; + + template::value> + struct __add_lvalue_reference_helper + { typedef _Tp type; }; + + template + struct __add_lvalue_reference_helper<_Tp, true> + { typedef _Tp& type; }; + + + template + struct add_lvalue_reference + : public __add_lvalue_reference_helper<_Tp> + { }; + + template::value> + struct __add_rvalue_reference_helper + { typedef _Tp type; }; + + template + struct __add_rvalue_reference_helper<_Tp, true> + { typedef _Tp&& type; }; + + + template + struct add_rvalue_reference + : public __add_rvalue_reference_helper<_Tp> + { }; + + + + template + using remove_reference_t = typename remove_reference<_Tp>::type; + + + template + using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; + + + template + using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; + + + + + + template + struct __cv_selector; + + template + struct __cv_selector<_Unqualified, false, false> + { typedef _Unqualified __type; }; + + template + struct __cv_selector<_Unqualified, false, true> + { typedef volatile _Unqualified __type; }; + + template + struct __cv_selector<_Unqualified, true, false> + { typedef const _Unqualified __type; }; + + template + struct __cv_selector<_Unqualified, true, true> + { typedef const volatile _Unqualified __type; }; + + template::value, + bool _IsVol = is_volatile<_Qualified>::value> + class __match_cv_qualifiers + { + typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match; + + public: + typedef typename __match::__type __type; + }; + + + template + struct __make_unsigned + { typedef _Tp __type; }; + + template<> + struct __make_unsigned + { typedef unsigned char __type; }; + + template<> + struct __make_unsigned + { typedef unsigned char __type; }; + + template<> + struct __make_unsigned + { typedef unsigned short __type; }; + + template<> + struct __make_unsigned + { typedef unsigned int __type; }; + + template<> + struct __make_unsigned + { typedef unsigned long __type; }; + + template<> + struct __make_unsigned + { typedef unsigned long long __type; }; + + + template<> + struct __make_unsigned : __make_unsigned + { }; +# 1785 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + class __make_unsigned_selector; + + template + class __make_unsigned_selector<_Tp, true, false> + { + typedef __make_unsigned::type> __unsignedt; + typedef typename __unsignedt::__type __unsigned_type; + typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned; + + public: + typedef typename __cv_unsigned::__type __type; + }; + + template + class __make_unsigned_selector<_Tp, false, true> + { + + typedef unsigned char __smallest; + static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest); + static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short); + static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int); + static const bool __b3 = sizeof(_Tp) <= sizeof(unsigned long); + typedef conditional<__b3, unsigned long, unsigned long long> __cond3; + typedef typename __cond3::type __cond3_type; + typedef conditional<__b2, unsigned int, __cond3_type> __cond2; + typedef typename __cond2::type __cond2_type; + typedef conditional<__b1, unsigned short, __cond2_type> __cond1; + typedef typename __cond1::type __cond1_type; + + typedef typename conditional<__b0, __smallest, __cond1_type>::type + __unsigned_type; + typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned; + + public: + typedef typename __cv_unsigned::__type __type; + }; + + + + + + template + struct make_unsigned + { typedef typename __make_unsigned_selector<_Tp>::__type type; }; + + + template<> + struct make_unsigned; + + + + template + struct __make_signed + { typedef _Tp __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed short __type; }; + + template<> + struct __make_signed + { typedef signed int __type; }; + + template<> + struct __make_signed + { typedef signed long __type; }; + + template<> + struct __make_signed + { typedef signed long long __type; }; +# 1874 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3 + template<> + struct __make_signed : __make_signed + { }; + template<> + struct __make_signed : __make_signed + { }; +# 1904 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + class __make_signed_selector; + + template + class __make_signed_selector<_Tp, true, false> + { + typedef __make_signed::type> __signedt; + typedef typename __signedt::__type __signed_type; + typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed; + + public: + typedef typename __cv_signed::__type __type; + }; + + template + class __make_signed_selector<_Tp, false, true> + { + typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type; + + public: + typedef typename __make_signed_selector<__unsigned_type>::__type __type; + }; + + + + + + template + struct make_signed + { typedef typename __make_signed_selector<_Tp>::__type type; }; + + + template<> + struct make_signed; + + + + template + using make_signed_t = typename make_signed<_Tp>::type; + + + template + using make_unsigned_t = typename make_unsigned<_Tp>::type; + + + + + + template + struct remove_extent + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[_Size]> + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[]> + { typedef _Tp type; }; + + + template + struct remove_all_extents + { typedef _Tp type; }; + + template + struct remove_all_extents<_Tp[_Size]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + template + struct remove_all_extents<_Tp[]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + + + template + using remove_extent_t = typename remove_extent<_Tp>::type; + + + template + using remove_all_extents_t = typename remove_all_extents<_Tp>::type; + + + + + template + struct __remove_pointer_helper + { typedef _Tp type; }; + + template + struct __remove_pointer_helper<_Tp, _Up*> + { typedef _Up type; }; + + + template + struct remove_pointer + : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type> + { }; + + + template, + is_void<_Tp>>::value> + struct __add_pointer_helper + { typedef _Tp type; }; + + template + struct __add_pointer_helper<_Tp, true> + { typedef typename remove_reference<_Tp>::type* type; }; + + template + struct add_pointer + : public __add_pointer_helper<_Tp> + { }; + + + + template + using remove_pointer_t = typename remove_pointer<_Tp>::type; + + + template + using add_pointer_t = typename add_pointer<_Tp>::type; + + + template + struct __aligned_storage_msa + { + union __type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__)) { } __align; + }; + }; +# 2050 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3 + template::__type)> + struct aligned_storage + { + union type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__((_Align)))) { } __align; + }; + }; + + template + struct __strictest_alignment + { + static const size_t _S_alignment = 0; + static const size_t _S_size = 0; + }; + + template + struct __strictest_alignment<_Tp, _Types...> + { + static const size_t _S_alignment = + alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment + ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; + static const size_t _S_size = + sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size + ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; + }; +# 2089 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3 + template + struct aligned_union + { + private: + static_assert(sizeof...(_Types) != 0, "At least one type is required"); + + using __strictest = __strictest_alignment<_Types...>; + static const size_t _S_len = _Len > __strictest::_S_size + ? _Len : __strictest::_S_size; + public: + + static const size_t alignment_value = __strictest::_S_alignment; + + typedef typename aligned_storage<_S_len, alignment_value>::type type; + }; + + template + const size_t aligned_union<_Len, _Types...>::alignment_value; + + + + template::value, + bool _IsFunction = is_function<_Up>::value> + struct __decay_selector; + + + template + struct __decay_selector<_Up, false, false> + { typedef typename remove_cv<_Up>::type __type; }; + + template + struct __decay_selector<_Up, true, false> + { typedef typename remove_extent<_Up>::type* __type; }; + + template + struct __decay_selector<_Up, false, true> + { typedef typename add_pointer<_Up>::type __type; }; + + + template + class decay + { + typedef typename remove_reference<_Tp>::type __remove_type; + + public: + typedef typename __decay_selector<__remove_type>::__type type; + }; + + template + class reference_wrapper; + + + template + struct __strip_reference_wrapper + { + typedef _Tp __type; + }; + + template + struct __strip_reference_wrapper > + { + typedef _Tp& __type; + }; + + template + struct __decay_and_strip + { + typedef typename __strip_reference_wrapper< + typename decay<_Tp>::type>::__type __type; + }; + + + + + template + struct enable_if + { }; + + + template + struct enable_if + { typedef _Tp type; }; + + template + using _Require = typename enable_if<__and_<_Cond...>::value>::type; + + + + template + struct conditional + { typedef _Iftrue type; }; + + + template + struct conditional + { typedef _Iffalse type; }; + + + template + struct common_type; + + + + struct __do_common_type_impl + { + template + static __success_type() + : std::declval<_Up>())>::type> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __common_type_impl + : private __do_common_type_impl + { + typedef decltype(_S_test<_Tp, _Up>(0)) type; + }; + + struct __do_member_type_wrapper + { + template + static __success_type _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __member_type_wrapper + : private __do_member_type_wrapper + { + typedef decltype(_S_test<_Tp>(0)) type; + }; + + template + struct __expanded_common_type_wrapper + { + typedef common_type type; + }; + + template + struct __expanded_common_type_wrapper<__failure_type, _Args...> + { typedef __failure_type type; }; + + template + struct common_type<_Tp> + { typedef typename decay<_Tp>::type type; }; + + template + struct common_type<_Tp, _Up> + : public __common_type_impl<_Tp, _Up>::type + { }; + + template + struct common_type<_Tp, _Up, _Vp...> + : public __expanded_common_type_wrapper>::type, _Vp...>::type + { }; + + + template + struct underlying_type + { + typedef __underlying_type(_Tp) type; + }; + + template + struct __declval_protector + { + static const bool __stop = false; + static typename add_rvalue_reference<_Tp>::type __delegate(); + }; + + template + inline typename add_rvalue_reference<_Tp>::type + declval() noexcept + { + static_assert(__declval_protector<_Tp>::__stop, + "declval() must not be used!"); + return __declval_protector<_Tp>::__delegate(); + } + + + template + class result_of; + + + + + + struct __invoke_memfun_ref { }; + struct __invoke_memfun_deref { }; + struct __invoke_memobj_ref { }; + struct __invoke_memobj_deref { }; + struct __invoke_other { }; + + + template + struct __result_of_success : __success_type<_Tp> + { using __invoke_type = _Tag; }; + + + struct __result_of_memfun_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_ref + : private __result_of_memfun_ref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; + }; + + + struct __result_of_memfun_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_deref + : private __result_of_memfun_deref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; + }; + + + struct __result_of_memobj_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>() + ), __invoke_memobj_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_ref + : private __result_of_memobj_ref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + + struct __result_of_memobj_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>() + ), __invoke_memobj_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_deref + : private __result_of_memobj_deref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + template + struct __result_of_memobj; + + template + struct __result_of_memobj<_Res _Class::*, _Arg> + { + typedef typename remove_cv::type>::type _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename conditional<__or_, + is_base_of<_Class, _Argval>>::value, + __result_of_memobj_ref<_MemPtr, _Arg>, + __result_of_memobj_deref<_MemPtr, _Arg> + >::type::type type; + }; + + template + struct __result_of_memfun; + + template + struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> + { + typedef typename remove_cv::type>::type _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename conditional<__or_, + is_base_of<_Class, _Argval>>::value, + __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, + __result_of_memfun_deref<_MemPtr, _Arg, _Args...> + >::type::type type; + }; + + + + + + template + struct __result_of_memobj<_Res _Class::*, reference_wrapper<_Arg>> + : __result_of_memobj_ref<_Res _Class::*, _Arg&> + { }; + + template + struct __result_of_memobj<_Res _Class::*, reference_wrapper<_Arg>&> + : __result_of_memobj_ref<_Res _Class::*, _Arg&> + { }; + + template + struct __result_of_memobj<_Res _Class::*, const reference_wrapper<_Arg>&> + : __result_of_memobj_ref<_Res _Class::*, _Arg&> + { }; + + template + struct __result_of_memobj<_Res _Class::*, reference_wrapper<_Arg>&&> + : __result_of_memobj_ref<_Res _Class::*, _Arg&> + { }; + + template + struct __result_of_memobj<_Res _Class::*, const reference_wrapper<_Arg>&&> + : __result_of_memobj_ref<_Res _Class::*, _Arg&> + { }; + + template + struct __result_of_memfun<_Res _Class::*, reference_wrapper<_Arg>, _Args...> + : __result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...> + { }; + + template + struct __result_of_memfun<_Res _Class::*, reference_wrapper<_Arg>&, + _Args...> + : __result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...> + { }; + + template + struct __result_of_memfun<_Res _Class::*, const reference_wrapper<_Arg>&, + _Args...> + : __result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...> + { }; + + template + struct __result_of_memfun<_Res _Class::*, reference_wrapper<_Arg>&&, + _Args...> + : __result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...> + { }; + + template + struct __result_of_memfun<_Res _Class::*, const reference_wrapper<_Arg>&&, + _Args...> + : __result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...> + { }; + + template + struct __result_of_impl + { + typedef __failure_type type; + }; + + template + struct __result_of_impl + : public __result_of_memobj::type, _Arg> + { }; + + template + struct __result_of_impl + : public __result_of_memfun::type, _Arg, _Args...> + { }; + + + struct __result_of_other_impl + { + template + static __result_of_success()(std::declval<_Args>()...) + ), __invoke_other> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_impl + : private __result_of_other_impl + { + typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; + }; + + template + struct result_of<_Functor(_ArgTypes...)> + : public __result_of_impl< + is_member_object_pointer< + typename remove_reference<_Functor>::type + >::value, + is_member_function_pointer< + typename remove_reference<_Functor>::type + >::value, + _Functor, _ArgTypes... + >::type + { }; + + + + template::__type)> + using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; + + template + using aligned_union_t = typename aligned_union<_Len, _Types...>::type; + + + template + using decay_t = typename decay<_Tp>::type; + + + template + using enable_if_t = typename enable_if<_Cond, _Tp>::type; + + + template + using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; + + + template + using common_type_t = typename common_type<_Tp...>::type; + + + template + using underlying_type_t = typename underlying_type<_Tp>::type; + + + template + using result_of_t = typename result_of<_Tp>::type; + + + template using __void_t = void; +# 2551 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3 + template class _Op, typename... _Args> + struct __detector + { + using value_t = false_type; + using type = _Default; + }; + + + template class _Op, + typename... _Args> + struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> + { + using value_t = true_type; + using type = _Op<_Args...>; + }; + + + template class _Op, + typename... _Args> + using __detected_or = __detector<_Default, void, _Op, _Args...>; + + + template class _Op, + typename... _Args> + using __detected_or_t + = typename __detected_or<_Default, _Op, _Args...>::type; + + + template class _Default, + template class _Op, typename... _Args> + using __detected_or_t_ = + __detected_or_t<_Default<_Args...>, _Op, _Args...>; +# 2601 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3 + template + struct __is_swappable; + + template + struct __is_nothrow_swappable; + + template + inline + typename enable_if<__and_, + is_move_assignable<_Tp>>::value>::type + swap(_Tp&, _Tp&) + noexcept(__and_, + is_nothrow_move_assignable<_Tp>>::value); + + template + inline + typename enable_if<__is_swappable<_Tp>::value>::type + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value); + + namespace __swappable_details { + using std::swap; + + struct __do_is_swappable_impl + { + template(), std::declval<_Tp&>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_impl + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_nothrow_swappable_impl + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_swappable + : public __is_swappable_impl<_Tp>::type + { }; + + template + struct __is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { }; + + +} +# 58 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 74 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 3 + template + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Tp&&>(__t); } + + + + + + + + template + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type&& __t) noexcept + { + static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument" + " substituting _Tp is an lvalue reference type"); + return static_cast<_Tp&&>(__t); + } + + + + + + + template + constexpr typename std::remove_reference<_Tp>::type&& + move(_Tp&& __t) noexcept + { return static_cast::type&&>(__t); } + + + template + struct __move_if_noexcept_cond + : public __and_<__not_>, + is_copy_constructible<_Tp>>::type { }; +# 118 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 3 + template + constexpr typename + conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type + move_if_noexcept(_Tp& __x) noexcept + { return std::move(__x); } +# 133 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 3 + template + inline _Tp* + addressof(_Tp& __r) noexcept + { return std::__addressof(__r); } + + + template + inline _Tp + __exchange(_Tp& __obj, _Up&& __new_val) + { + _Tp __old_val = std::move(__obj); + __obj = std::forward<_Up>(__new_val); + return __old_val; + } + + + +} +# 159 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 174 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 3 + template + inline + + typename enable_if<__and_, + is_move_assignable<_Tp>>::value>::type + swap(_Tp& __a, _Tp& __b) + noexcept(__and_, + is_nothrow_move_assignable<_Tp>>::value) + + + + + { + + + + _Tp __tmp = std::move(__a); + __a = std::move(__b); + __b = std::move(__tmp); + } + + + + + template + inline + + typename enable_if<__is_swappable<_Tp>::value>::type + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value) + + + + + { + for (size_t __n = 0; __n < _Nm; ++__n) + swap(__a[__n], __b[__n]); + } + + + +} +# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/nested_exception.h" 2 3 + + + + + +extern "C++" { + +namespace std +{ + + + + + + + class nested_exception + { + exception_ptr _M_ptr; + + public: + nested_exception() noexcept : _M_ptr(current_exception()) { } + + nested_exception(const nested_exception&) noexcept = default; + + nested_exception& operator=(const nested_exception&) noexcept = default; + + virtual ~nested_exception() noexcept; + + [[noreturn]] + void + rethrow_nested() const + { + if (_M_ptr) + rethrow_exception(_M_ptr); + std::terminate(); + } + + exception_ptr + nested_ptr() const noexcept + { return _M_ptr; } + }; + + template + struct _Nested_exception : public _Except, public nested_exception + { + explicit _Nested_exception(const _Except& __ex) + : _Except(__ex) + { } + + explicit _Nested_exception(_Except&& __ex) + : _Except(static_cast<_Except&&>(__ex)) + { } + }; + + + + + template + inline void + __throw_with_nested_impl(_Tp&& __t, true_type) + { + using _Up = typename remove_reference<_Tp>::type; + throw _Nested_exception<_Up>{std::forward<_Tp>(__t)}; + } + + template + inline void + __throw_with_nested_impl(_Tp&& __t, false_type) + { throw std::forward<_Tp>(__t); } + + + + template + [[noreturn]] + inline void + throw_with_nested(_Tp&& __t) + { + using _Up = typename remove_reference<_Tp>::type; + using _CopyConstructible + = __and_, is_move_constructible<_Up>>; + static_assert(_CopyConstructible::value, + "throw_with_nested argument must be CopyConstructible"); + using __nest = __and_, __bool_constant, + __not_>>; + std::__throw_with_nested_impl(std::forward<_Tp>(__t), __nest{}); + } + + + template + using __rethrow_if_nested_cond = typename enable_if< + __and_, + __or_<__not_>, + is_convertible<_Tp*, nested_exception*>>>::value + >::type; + + + template + inline __rethrow_if_nested_cond<_Ex> + __rethrow_if_nested_impl(const _Ex* __ptr) + { + if (auto __ne_ptr = dynamic_cast(__ptr)) + __ne_ptr->rethrow_nested(); + } + + + inline void + __rethrow_if_nested_impl(const void*) + { } + + + template + inline void + rethrow_if_nested(const _Ex& __ex) + { std::__rethrow_if_nested_impl(std::__addressof(__ex)); } + + +} + +} + + + +#pragma GCC visibility pop +# 172 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 2 3 +# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/new" 2 3 + +#pragma GCC visibility push(default) + +extern "C++" { + +namespace std +{ + + + + + + + class bad_alloc : public exception + { + public: + bad_alloc() throw() { } + + + + virtual ~bad_alloc() throw(); + + + virtual const char* what() const throw(); + }; + + + class bad_array_new_length : public bad_alloc + { + public: + bad_array_new_length() throw() { }; + + + + virtual ~bad_array_new_length() throw(); + + + virtual const char* what() const throw(); + }; + + + struct nothrow_t + { + + explicit nothrow_t() = default; + + }; + + extern const nothrow_t nothrow; + + + + typedef void (*new_handler)(); + + + + new_handler set_new_handler(new_handler) throw(); + + + + new_handler get_new_handler() noexcept; + +} +# 116 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/new" 3 +void* operator new(std::size_t) + __attribute__((__externally_visible__)); +void* operator new[](std::size_t) + __attribute__((__externally_visible__)); +void operator delete(void*) noexcept + __attribute__((__externally_visible__)); +void operator delete[](void*) noexcept + __attribute__((__externally_visible__)); + + + + + + +void* operator new(std::size_t, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__)); +void* operator new[](std::size_t, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__)); +void operator delete(void*, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__)); +void operator delete[](void*, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__)); +# 146 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/new" 3 +inline void* operator new(std::size_t, void* __p) noexcept +{ return __p; } +inline void* operator new[](std::size_t, void* __p) noexcept +{ return __p; } + + +inline void operator delete (void*, void*) noexcept { } +inline void operator delete[](void*, void*) noexcept { } + +} + +#pragma GCC visibility pop +# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 2 + + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3 +# 75 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3 +# 1 "/usr/include/stdlib.h" 1 3 4 +# 32 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4 +# 33 "/usr/include/stdlib.h" 2 3 4 + +extern "C" { + + + + + + + +# 1 "/usr/include/bits/waitflags.h" 1 3 4 +# 42 "/usr/include/stdlib.h" 2 3 4 +# 1 "/usr/include/bits/waitstatus.h" 1 3 4 +# 43 "/usr/include/stdlib.h" 2 3 4 +# 58 "/usr/include/stdlib.h" 3 4 +typedef struct + { + int quot; + int rem; + } div_t; + + + +typedef struct + { + long int quot; + long int rem; + } ldiv_t; + + + + + + + +__extension__ typedef struct + { + long long int quot; + long long int rem; + } lldiv_t; +# 100 "/usr/include/stdlib.h" 3 4 +extern size_t __ctype_get_mb_cur_max (void) throw () ; + + + + +extern double atof (const char *__nptr) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern int atoi (const char *__nptr) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern long int atol (const char *__nptr) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + + + +__extension__ extern long long int atoll (const char *__nptr) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + + + +extern double strtod (const char *__restrict __nptr, + char **__restrict __endptr) + throw () __attribute__ ((__nonnull__ (1))); + + + + + +extern float strtof (const char *__restrict __nptr, + char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1))); + +extern long double strtold (const char *__restrict __nptr, + char **__restrict __endptr) + throw () __attribute__ ((__nonnull__ (1))); + + + + + +extern long int strtol (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + throw () __attribute__ ((__nonnull__ (1))); + +extern unsigned long int strtoul (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + throw () __attribute__ ((__nonnull__ (1))); + + + + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + throw () __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + throw () __attribute__ ((__nonnull__ (1))); + + + + + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + throw () __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + throw () __attribute__ ((__nonnull__ (1))); +# 200 "/usr/include/stdlib.h" 3 4 +extern long int strtol_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + __locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4))); + +extern unsigned long int strtoul_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, __locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + __locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, __locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 4))); + +extern double strtod_l (const char *__restrict __nptr, + char **__restrict __endptr, __locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 3))); + +extern float strtof_l (const char *__restrict __nptr, + char **__restrict __endptr, __locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 3))); + +extern long double strtold_l (const char *__restrict __nptr, + char **__restrict __endptr, + __locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 3))); +# 266 "/usr/include/stdlib.h" 3 4 +extern char *l64a (long int __n) throw () ; + + +extern long int a64l (const char *__s) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + + + +# 1 "/usr/include/sys/types.h" 1 3 4 +# 27 "/usr/include/sys/types.h" 3 4 +extern "C" { + + + + + +typedef __u_char u_char; +typedef __u_short u_short; +typedef __u_int u_int; +typedef __u_long u_long; +typedef __quad_t quad_t; +typedef __u_quad_t u_quad_t; +typedef __fsid_t fsid_t; + + + + +typedef __loff_t loff_t; + + + +typedef __ino_t ino_t; + + + + + + +typedef __ino64_t ino64_t; + + + + +typedef __dev_t dev_t; + + + + +typedef __gid_t gid_t; + + + + +typedef __mode_t mode_t; + + + + +typedef __nlink_t nlink_t; + + + + +typedef __uid_t uid_t; +# 98 "/usr/include/sys/types.h" 3 4 +typedef __pid_t pid_t; + + + + + +typedef __id_t id_t; +# 115 "/usr/include/sys/types.h" 3 4 +typedef __daddr_t daddr_t; +typedef __caddr_t caddr_t; + + + + + +typedef __key_t key_t; +# 132 "/usr/include/sys/types.h" 3 4 +# 1 "/usr/include/time.h" 1 3 4 +# 59 "/usr/include/time.h" 3 4 +typedef __clock_t clock_t; +# 75 "/usr/include/time.h" 3 4 +typedef __time_t time_t; +# 91 "/usr/include/time.h" 3 4 +typedef __clockid_t clockid_t; +# 103 "/usr/include/time.h" 3 4 +typedef __timer_t timer_t; +# 133 "/usr/include/sys/types.h" 2 3 4 + + + +typedef __useconds_t useconds_t; + + + +typedef __suseconds_t suseconds_t; + + + + + + +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4 +# 147 "/usr/include/sys/types.h" 2 3 4 + + + +typedef unsigned long int ulong; +typedef unsigned short int ushort; +typedef unsigned int uint; +# 200 "/usr/include/sys/types.h" 3 4 +typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__))); +typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__))); +typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__))); +typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__))); + +typedef int register_t __attribute__ ((__mode__ (__word__))); +# 216 "/usr/include/sys/types.h" 3 4 +# 1 "/usr/include/endian.h" 1 3 4 +# 36 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/bits/endian.h" 1 3 4 +# 37 "/usr/include/endian.h" 2 3 4 +# 60 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/bits/byteswap.h" 1 3 4 +# 28 "/usr/include/bits/byteswap.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 29 "/usr/include/bits/byteswap.h" 2 3 4 + + + + + + +# 1 "/usr/include/bits/byteswap-16.h" 1 3 4 +# 36 "/usr/include/bits/byteswap.h" 2 3 4 +# 61 "/usr/include/endian.h" 2 3 4 +# 217 "/usr/include/sys/types.h" 2 3 4 + + +# 1 "/usr/include/sys/select.h" 1 3 4 +# 30 "/usr/include/sys/select.h" 3 4 +# 1 "/usr/include/bits/select.h" 1 3 4 +# 22 "/usr/include/bits/select.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 23 "/usr/include/bits/select.h" 2 3 4 +# 31 "/usr/include/sys/select.h" 2 3 4 + + +# 1 "/usr/include/bits/sigset.h" 1 3 4 +# 22 "/usr/include/bits/sigset.h" 3 4 +typedef int __sig_atomic_t; + + + + +typedef struct + { + unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; + } __sigset_t; +# 34 "/usr/include/sys/select.h" 2 3 4 + + + +typedef __sigset_t sigset_t; + + + + + + + + +# 1 "/usr/include/time.h" 1 3 4 +# 120 "/usr/include/time.h" 3 4 +struct timespec + { + __time_t tv_sec; + __syscall_slong_t tv_nsec; + }; +# 46 "/usr/include/sys/select.h" 2 3 4 + +# 1 "/usr/include/bits/time.h" 1 3 4 +# 30 "/usr/include/bits/time.h" 3 4 +struct timeval + { + __time_t tv_sec; + __suseconds_t tv_usec; + }; +# 48 "/usr/include/sys/select.h" 2 3 4 + + + + + + + + +typedef long int __fd_mask; +# 66 "/usr/include/sys/select.h" 3 4 +typedef struct + { + + + + __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; + + + + + + } fd_set; + + + + + + +typedef __fd_mask fd_mask; +# 98 "/usr/include/sys/select.h" 3 4 +extern "C" { +# 108 "/usr/include/sys/select.h" 3 4 +extern int select (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + struct timeval *__restrict __timeout); +# 120 "/usr/include/sys/select.h" 3 4 +extern int pselect (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + const struct timespec *__restrict __timeout, + const __sigset_t *__restrict __sigmask); +# 133 "/usr/include/sys/select.h" 3 4 +} +# 220 "/usr/include/sys/types.h" 2 3 4 + + +# 1 "/usr/include/sys/sysmacros.h" 1 3 4 +# 24 "/usr/include/sys/sysmacros.h" 3 4 +extern "C" { + +__extension__ +extern unsigned int gnu_dev_major (unsigned long long int __dev) + throw () __attribute__ ((__const__)); +__extension__ +extern unsigned int gnu_dev_minor (unsigned long long int __dev) + throw () __attribute__ ((__const__)); +__extension__ +extern unsigned long long int gnu_dev_makedev (unsigned int __major, + unsigned int __minor) + throw () __attribute__ ((__const__)); +# 58 "/usr/include/sys/sysmacros.h" 3 4 +} +# 223 "/usr/include/sys/types.h" 2 3 4 + + + + + +typedef __blksize_t blksize_t; + + + + + + +typedef __blkcnt_t blkcnt_t; + + + +typedef __fsblkcnt_t fsblkcnt_t; + + + +typedef __fsfilcnt_t fsfilcnt_t; +# 262 "/usr/include/sys/types.h" 3 4 +typedef __blkcnt64_t blkcnt64_t; +typedef __fsblkcnt64_t fsblkcnt64_t; +typedef __fsfilcnt64_t fsfilcnt64_t; + + + + + + +# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4 +# 21 "/usr/include/bits/pthreadtypes.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 22 "/usr/include/bits/pthreadtypes.h" 2 3 4 +# 60 "/usr/include/bits/pthreadtypes.h" 3 4 +typedef unsigned long int pthread_t; + + +union pthread_attr_t +{ + char __size[56]; + long int __align; +}; + +typedef union pthread_attr_t pthread_attr_t; + + + + + +typedef struct __pthread_internal_list +{ + struct __pthread_internal_list *__prev; + struct __pthread_internal_list *__next; +} __pthread_list_t; +# 90 "/usr/include/bits/pthreadtypes.h" 3 4 +typedef union +{ + struct __pthread_mutex_s + { + int __lock; + unsigned int __count; + int __owner; + + unsigned int __nusers; + + + + int __kind; + + short __spins; + short __elision; + __pthread_list_t __list; +# 125 "/usr/include/bits/pthreadtypes.h" 3 4 + } __data; + char __size[40]; + long int __align; +} pthread_mutex_t; + +typedef union +{ + char __size[4]; + int __align; +} pthread_mutexattr_t; + + + + +typedef union +{ + struct + { + int __lock; + unsigned int __futex; + __extension__ unsigned long long int __total_seq; + __extension__ unsigned long long int __wakeup_seq; + __extension__ unsigned long long int __woken_seq; + void *__mutex; + unsigned int __nwaiters; + unsigned int __broadcast_seq; + } __data; + char __size[48]; + __extension__ long long int __align; +} pthread_cond_t; + +typedef union +{ + char __size[4]; + int __align; +} pthread_condattr_t; + + + +typedef unsigned int pthread_key_t; + + + +typedef int pthread_once_t; + + + + + +typedef union +{ + + struct + { + int __lock; + unsigned int __nr_readers; + unsigned int __readers_wakeup; + unsigned int __writer_wakeup; + unsigned int __nr_readers_queued; + unsigned int __nr_writers_queued; + int __writer; + int __shared; + signed char __rwelision; + + + + + unsigned char __pad1[7]; + + + unsigned long int __pad2; + + + unsigned int __flags; + + } __data; +# 220 "/usr/include/bits/pthreadtypes.h" 3 4 + char __size[56]; + long int __align; +} pthread_rwlock_t; + +typedef union +{ + char __size[8]; + long int __align; +} pthread_rwlockattr_t; + + + + + +typedef volatile int pthread_spinlock_t; + + + + +typedef union +{ + char __size[32]; + long int __align; +} pthread_barrier_t; + +typedef union +{ + char __size[4]; + int __align; +} pthread_barrierattr_t; +# 271 "/usr/include/sys/types.h" 2 3 4 + + +} +# 276 "/usr/include/stdlib.h" 2 3 4 + + + + + + +extern long int random (void) throw (); + + +extern void srandom (unsigned int __seed) throw (); + + + + + +extern char *initstate (unsigned int __seed, char *__statebuf, + size_t __statelen) throw () __attribute__ ((__nonnull__ (2))); + + + +extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1))); + + + + + + + +struct random_data + { + int32_t *fptr; + int32_t *rptr; + int32_t *state; + int rand_type; + int rand_deg; + int rand_sep; + int32_t *end_ptr; + }; + +extern int random_r (struct random_data *__restrict __buf, + int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2))); + +extern int srandom_r (unsigned int __seed, struct random_data *__buf) + throw () __attribute__ ((__nonnull__ (2))); + +extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, + size_t __statelen, + struct random_data *__restrict __buf) + throw () __attribute__ ((__nonnull__ (2, 4))); + +extern int setstate_r (char *__restrict __statebuf, + struct random_data *__restrict __buf) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + + + +extern int rand (void) throw (); + +extern void srand (unsigned int __seed) throw (); + + + + +extern int rand_r (unsigned int *__seed) throw (); + + + + + + + +extern double drand48 (void) throw (); +extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1))); + + +extern long int lrand48 (void) throw (); +extern long int nrand48 (unsigned short int __xsubi[3]) + throw () __attribute__ ((__nonnull__ (1))); + + +extern long int mrand48 (void) throw (); +extern long int jrand48 (unsigned short int __xsubi[3]) + throw () __attribute__ ((__nonnull__ (1))); + + +extern void srand48 (long int __seedval) throw (); +extern unsigned short int *seed48 (unsigned short int __seed16v[3]) + throw () __attribute__ ((__nonnull__ (1))); +extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1))); + + + + + +struct drand48_data + { + unsigned short int __x[3]; + unsigned short int __old_x[3]; + unsigned short int __c; + unsigned short int __init; + __extension__ unsigned long long int __a; + + }; + + +extern int drand48_r (struct drand48_data *__restrict __buffer, + double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2))); +extern int erand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int lrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + throw () __attribute__ ((__nonnull__ (1, 2))); +extern int nrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int mrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + throw () __attribute__ ((__nonnull__ (1, 2))); +extern int jrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int srand48_r (long int __seedval, struct drand48_data *__buffer) + throw () __attribute__ ((__nonnull__ (2))); + +extern int seed48_r (unsigned short int __seed16v[3], + struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2))); + +extern int lcong48_r (unsigned short int __param[7], + struct drand48_data *__buffer) + throw () __attribute__ ((__nonnull__ (1, 2))); +# 427 "/usr/include/stdlib.h" 3 4 +extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) ; + +extern void *calloc (size_t __nmemb, size_t __size) + throw () __attribute__ ((__malloc__)) ; +# 441 "/usr/include/stdlib.h" 3 4 +extern void *realloc (void *__ptr, size_t __size) + throw () __attribute__ ((__warn_unused_result__)); + +extern void free (void *__ptr) throw (); + + + + +extern void cfree (void *__ptr) throw (); + + + + +# 1 "/usr/include/alloca.h" 1 3 4 +# 24 "/usr/include/alloca.h" 3 4 +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4 +# 25 "/usr/include/alloca.h" 2 3 4 + +extern "C" { + + + + + +extern void *alloca (size_t __size) throw (); + + + + + +} +# 454 "/usr/include/stdlib.h" 2 3 4 + + + + + +extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) ; + + + + +extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) + throw () __attribute__ ((__nonnull__ (1))) ; + + + + +extern void *aligned_alloc (size_t __alignment, size_t __size) + throw () __attribute__ ((__malloc__)) ; + + + + +extern void abort (void) throw () __attribute__ ((__noreturn__)); + + + +extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1))); + + + + +extern "C++" int at_quick_exit (void (*__func) (void)) + throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1))); +# 496 "/usr/include/stdlib.h" 3 4 +extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) + throw () __attribute__ ((__nonnull__ (1))); + + + + + + +extern void exit (int __status) throw () __attribute__ ((__noreturn__)); + + + + + +extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__)); + + + + + + + +extern void _Exit (int __status) throw () __attribute__ ((__noreturn__)); + + + + + + +extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ; + + + + + +extern char *secure_getenv (const char *__name) + throw () __attribute__ ((__nonnull__ (1))) ; + + + + + + +extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1))); + + + + + +extern int setenv (const char *__name, const char *__value, int __replace) + throw () __attribute__ ((__nonnull__ (2))); + + +extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))); + + + + + + +extern int clearenv (void) throw (); +# 567 "/usr/include/stdlib.h" 3 4 +extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1))); +# 580 "/usr/include/stdlib.h" 3 4 +extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 590 "/usr/include/stdlib.h" 3 4 +extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 602 "/usr/include/stdlib.h" 3 4 +extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; +# 612 "/usr/include/stdlib.h" 3 4 +extern int mkstemps64 (char *__template, int __suffixlen) + __attribute__ ((__nonnull__ (1))) ; +# 623 "/usr/include/stdlib.h" 3 4 +extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ; +# 634 "/usr/include/stdlib.h" 3 4 +extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 644 "/usr/include/stdlib.h" 3 4 +extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 654 "/usr/include/stdlib.h" 3 4 +extern int mkostemps (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 666 "/usr/include/stdlib.h" 3 4 +extern int mkostemps64 (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 677 "/usr/include/stdlib.h" 3 4 +extern int system (const char *__command) ; + + + + + + +extern char *canonicalize_file_name (const char *__name) + throw () __attribute__ ((__nonnull__ (1))) ; +# 694 "/usr/include/stdlib.h" 3 4 +extern char *realpath (const char *__restrict __name, + char *__restrict __resolved) throw () ; + + + + + + +typedef int (*__compar_fn_t) (const void *, const void *); + + +typedef __compar_fn_t comparison_fn_t; + + + +typedef int (*__compar_d_fn_t) (const void *, const void *, void *); + + + + + +extern void *bsearch (const void *__key, const void *__base, + size_t __nmemb, size_t __size, __compar_fn_t __compar) + __attribute__ ((__nonnull__ (1, 2, 5))) ; + + + + + + + +extern void qsort (void *__base, size_t __nmemb, size_t __size, + __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4))); + +extern void qsort_r (void *__base, size_t __nmemb, size_t __size, + __compar_d_fn_t __compar, void *__arg) + __attribute__ ((__nonnull__ (1, 4))); + + + + +extern int abs (int __x) throw () __attribute__ ((__const__)) ; +extern long int labs (long int __x) throw () __attribute__ ((__const__)) ; + + + +__extension__ extern long long int llabs (long long int __x) + throw () __attribute__ ((__const__)) ; + + + + + + + +extern div_t div (int __numer, int __denom) + throw () __attribute__ ((__const__)) ; +extern ldiv_t ldiv (long int __numer, long int __denom) + throw () __attribute__ ((__const__)) ; + + + + +__extension__ extern lldiv_t lldiv (long long int __numer, + long long int __denom) + throw () __attribute__ ((__const__)) ; +# 772 "/usr/include/stdlib.h" 3 4 +extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *gcvt (double __value, int __ndigit, char *__buf) + throw () __attribute__ ((__nonnull__ (3))) ; + + + + +extern char *qecvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + throw () __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qfcvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + throw () __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qgcvt (long double __value, int __ndigit, char *__buf) + throw () __attribute__ ((__nonnull__ (3))) ; + + + + +extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5))); +extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5))); + +extern int qecvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + throw () __attribute__ ((__nonnull__ (3, 4, 5))); +extern int qfcvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + throw () __attribute__ ((__nonnull__ (3, 4, 5))); + + + + + + +extern int mblen (const char *__s, size_t __n) throw (); + + +extern int mbtowc (wchar_t *__restrict __pwc, + const char *__restrict __s, size_t __n) throw (); + + +extern int wctomb (char *__s, wchar_t __wchar) throw (); + + + +extern size_t mbstowcs (wchar_t *__restrict __pwcs, + const char *__restrict __s, size_t __n) throw (); + +extern size_t wcstombs (char *__restrict __s, + const wchar_t *__restrict __pwcs, size_t __n) + throw (); +# 848 "/usr/include/stdlib.h" 3 4 +extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ; +# 859 "/usr/include/stdlib.h" 3 4 +extern int getsubopt (char **__restrict __optionp, + char *const *__restrict __tokens, + char **__restrict __valuep) + throw () __attribute__ ((__nonnull__ (1, 2, 3))) ; + + + + + +extern void setkey (const char *__key) throw () __attribute__ ((__nonnull__ (1))); + + + + + + + +extern int posix_openpt (int __oflag) ; + + + + + + + +extern int grantpt (int __fd) throw (); + + + +extern int unlockpt (int __fd) throw (); + + + + +extern char *ptsname (int __fd) throw () ; + + + + + + +extern int ptsname_r (int __fd, char *__buf, size_t __buflen) + throw () __attribute__ ((__nonnull__ (2))); + + +extern int getpt (void); + + + + + + +extern int getloadavg (double __loadavg[], int __nelem) + throw () __attribute__ ((__nonnull__ (1))); +# 921 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/stdlib-float.h" 1 3 4 +# 922 "/usr/include/stdlib.h" 2 3 4 +# 934 "/usr/include/stdlib.h" 3 4 +} +# 76 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 2 3 +# 118 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::div_t; + using ::ldiv_t; + + using ::abort; + using ::abs; + using ::atexit; + + + using ::at_quick_exit; + + + using ::atof; + using ::atoi; + using ::atol; + using ::bsearch; + using ::calloc; + using ::div; + using ::exit; + using ::free; + using ::getenv; + using ::labs; + using ::ldiv; + using ::malloc; + + using ::mblen; + using ::mbstowcs; + using ::mbtowc; + + using ::qsort; + + + using ::quick_exit; + + + using ::rand; + using ::realloc; + using ::srand; + using ::strtod; + using ::strtol; + using ::strtoul; + using ::system; + + using ::wcstombs; + using ::wctomb; + + + + inline long + abs(long __i) { return __builtin_labs(__i); } + + inline ldiv_t + div(long __i, long __j) { return ldiv(__i, __j); } + + + + inline long long + abs(long long __x) { return __builtin_llabs (__x); } +# 202 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3 +} +# 215 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3 +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + using ::lldiv_t; + + + + + + using ::_Exit; + + + + using ::llabs; + + inline lldiv_t + div(long long __n, long long __d) + { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; } + + using ::lldiv; +# 247 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3 + using ::atoll; + using ::strtoll; + using ::strtoull; + + using ::strtof; + using ::strtold; + + +} + +namespace std +{ + + using ::__gnu_cxx::lldiv_t; + + using ::__gnu_cxx::_Exit; + + using ::__gnu_cxx::llabs; + using ::__gnu_cxx::div; + using ::__gnu_cxx::lldiv; + + using ::__gnu_cxx::atoll; + using ::__gnu_cxx::strtof; + using ::__gnu_cxx::strtoll; + using ::__gnu_cxx::strtoull; + using ::__gnu_cxx::strtold; +} + + + +} +# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 2 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstring" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstring" 3 + + +# 1 "/usr/include/string.h" 1 3 4 +# 27 "/usr/include/string.h" 3 4 +extern "C" { + + + + + +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4 +# 33 "/usr/include/string.h" 2 3 4 +# 42 "/usr/include/string.h" 3 4 +extern void *memcpy (void *__restrict __dest, const void *__restrict __src, + size_t __n) throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern void *memmove (void *__dest, const void *__src, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + + + +extern void *memccpy (void *__restrict __dest, const void *__restrict __src, + int __c, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1))); + + +extern int memcmp (const void *__s1, const void *__s2, size_t __n) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 92 "/usr/include/string.h" 3 4 +extern void *memchr (const void *__s, int __c, size_t __n) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 106 "/usr/include/string.h" 3 4 +extern void *rawmemchr (const void *__s, int __c) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 117 "/usr/include/string.h" 3 4 +extern void *memrchr (const void *__s, int __c, size_t __n) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + + +extern char *strcpy (char *__restrict __dest, const char *__restrict __src) + throw () __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strcat (char *__restrict __dest, const char *__restrict __src) + throw () __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncat (char *__restrict __dest, const char *__restrict __src, + size_t __n) throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcmp (const char *__s1, const char *__s2) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern int strncmp (const char *__s1, const char *__s2, size_t __n) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcoll (const char *__s1, const char *__s2) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern size_t strxfrm (char *__restrict __dest, + const char *__restrict __src, size_t __n) + throw () __attribute__ ((__nonnull__ (2))); +# 162 "/usr/include/string.h" 3 4 +extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + +extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n, + __locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4))); + + + + +extern char *strdup (const char *__s) + throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); + + + + + + +extern char *strndup (const char *__string, size_t __n) + throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); +# 231 "/usr/include/string.h" 3 4 +extern char *strchr (const char *__s, int __c) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 258 "/usr/include/string.h" 3 4 +extern char *strrchr (const char *__s, int __c) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 272 "/usr/include/string.h" 3 4 +extern char *strchrnul (const char *__s, int __c) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + + +extern size_t strcspn (const char *__s, const char *__reject) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern size_t strspn (const char *__s, const char *__accept) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 310 "/usr/include/string.h" 3 4 +extern char *strpbrk (const char *__s, const char *__accept) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 337 "/usr/include/string.h" 3 4 +extern char *strstr (const char *__haystack, const char *__needle) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern char *strtok (char *__restrict __s, const char *__restrict __delim) + throw () __attribute__ ((__nonnull__ (2))); + + + + +extern char *__strtok_r (char *__restrict __s, + const char *__restrict __delim, + char **__restrict __save_ptr) + throw () __attribute__ ((__nonnull__ (2, 3))); + +extern char *strtok_r (char *__restrict __s, const char *__restrict __delim, + char **__restrict __save_ptr) + throw () __attribute__ ((__nonnull__ (2, 3))); +# 368 "/usr/include/string.h" 3 4 +extern char *strcasestr (const char *__haystack, const char *__needle) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + + + + + +extern void *memmem (const void *__haystack, size_t __haystacklen, + const void *__needle, size_t __needlelen) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3))); + + + +extern void *__mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); +extern void *mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern size_t strlen (const char *__s) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + +extern size_t strnlen (const char *__string, size_t __maxlen) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + +extern char *strerror (int __errnum) throw (); +# 433 "/usr/include/string.h" 3 4 +extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) + throw () __attribute__ ((__nonnull__ (2))) ; + + + + + +extern char *strerror_l (int __errnum, __locale_t __l) throw (); + + + + + +extern void __bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1))); + + + +extern void bcopy (const void *__src, void *__dest, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1))); + + +extern int bcmp (const void *__s1, const void *__s2, size_t __n) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 484 "/usr/include/string.h" 3 4 +extern char *index (const char *__s, int __c) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 512 "/usr/include/string.h" 3 4 +extern char *rindex (const char *__s, int __c) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + +extern int ffs (int __i) throw () __attribute__ ((__const__)); + + + + +extern int ffsl (long int __l) throw () __attribute__ ((__const__)); +__extension__ extern int ffsll (long long int __ll) + throw () __attribute__ ((__const__)); + + + +extern int strcasecmp (const char *__s1, const char *__s2) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strncasecmp (const char *__s1, const char *__s2, size_t __n) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern int strcasecmp_l (const char *__s1, const char *__s2, + __locale_t __loc) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + +extern int strncasecmp_l (const char *__s1, const char *__s2, + size_t __n, __locale_t __loc) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4))); + + + + + +extern char *strsep (char **__restrict __stringp, + const char *__restrict __delim) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + +extern char *strsignal (int __sig) throw (); + + +extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src) + throw () __attribute__ ((__nonnull__ (1, 2))); +extern char *stpcpy (char *__restrict __dest, const char *__restrict __src) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + +extern char *__stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); +extern char *stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + +extern int strverscmp (const char *__s1, const char *__s2) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1))); + + +extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1))); +# 599 "/usr/include/string.h" 3 4 +extern char *basename (const char *__filename) throw () __attribute__ ((__nonnull__ (1))); +# 656 "/usr/include/string.h" 3 4 +} +# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstring" 2 3 +# 71 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstring" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::memchr; + using ::memcmp; + using ::memcpy; + using ::memmove; + using ::memset; + using ::strcat; + using ::strcmp; + using ::strcoll; + using ::strcpy; + using ::strcspn; + using ::strerror; + using ::strlen; + using ::strncat; + using ::strncmp; + using ::strncpy; + using ::strspn; + using ::strtok; + using ::strxfrm; + using ::strchr; + using ::strpbrk; + using ::strrchr; + using ::strstr; + + + inline void* + memchr(void* __s, int __c, size_t __n) + { return __builtin_memchr(__s, __c, __n); } + + inline char* + strchr(char* __s, int __n) + { return __builtin_strchr(__s, __n); } + + inline char* + strpbrk(char* __s1, const char* __s2) + { return __builtin_strpbrk(__s1, __s2); } + + inline char* + strrchr(char* __s, int __n) + { return __builtin_strrchr(__s, __n); } + + inline char* + strstr(char* __s1, const char* __s2) + { return __builtin_strstr(__s1, __s2); } + + + +} +# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 2 + + + + + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/fallible.h" 1 +# 51 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/fallible.h" +namespace mozilla { + +struct fallible_t { }; +# 62 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/fallible.h" +extern const fallible_t fallible; + +} +# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc_abort.h" 1 +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc_abort.h" +__attribute__((weak)) __attribute__((visibility("default"))) + + __attribute__((noreturn)) + + void mozalloc_abort(const char* const msg); +# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TemplateLib.h" 1 +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TemplateLib.h" +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/limits.h" 1 3 +# 37 "/usr/local/bin/../lib/clang/3.9.1/include/limits.h" 3 +# 1 "/usr/include/limits.h" 1 3 4 +# 143 "/usr/include/limits.h" 3 4 +# 1 "/usr/include/bits/posix1_lim.h" 1 3 4 +# 160 "/usr/include/bits/posix1_lim.h" 3 4 +# 1 "/usr/include/bits/local_lim.h" 1 3 4 +# 38 "/usr/include/bits/local_lim.h" 3 4 +# 1 "/usr/include/linux/limits.h" 1 3 4 +# 39 "/usr/include/bits/local_lim.h" 2 3 4 +# 161 "/usr/include/bits/posix1_lim.h" 2 3 4 +# 144 "/usr/include/limits.h" 2 3 4 + + + +# 1 "/usr/include/bits/posix2_lim.h" 1 3 4 +# 148 "/usr/include/limits.h" 2 3 4 + + + +# 1 "/usr/include/bits/xopen_lim.h" 1 3 4 +# 33 "/usr/include/bits/xopen_lim.h" 3 4 +# 1 "/usr/include/bits/stdio_lim.h" 1 3 4 +# 34 "/usr/include/bits/xopen_lim.h" 2 3 4 +# 152 "/usr/include/limits.h" 2 3 4 +# 38 "/usr/local/bin/../lib/clang/3.9.1/include/limits.h" 2 3 +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TemplateLib.h" 2 +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 +# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TemplateLib.h" 2 + + + +namespace mozilla { + +namespace tl { + + +template +struct Min +{ + static constexpr size_t value = + Size < Min::value + ? Size + : Min::value; +}; + +template +struct Min +{ + static constexpr size_t value = Size; +}; + +template +struct Max +{ + static constexpr size_t value = + Size > Max::value + ? Size + : Max::value; +}; + +template +struct Max +{ + static constexpr size_t value = Size; +}; + + +template +struct FloorLog2 +{ + static const size_t value = 1 + FloorLog2::value; +}; +template<> struct FloorLog2<0> { }; +template<> struct FloorLog2<1> { static const size_t value = 0; }; + + +template +struct CeilingLog2 +{ + static const size_t value = FloorLog2<2 * I - 1>::value; +}; + + +template +struct RoundUpPow2 +{ + static const size_t value = size_t(1) << CeilingLog2::value; +}; +template<> +struct RoundUpPow2<0> +{ + static const size_t value = 1; +}; + + +template +struct BitSize +{ + static const size_t value = sizeof(T) * 8; +}; + + + + + +template +struct NBitMask +{ + + + + + static const size_t checkPrecondition = + 0 / size_t(N < BitSize::value); + static const size_t value = (size_t(1) << N) - 1 + checkPrecondition; +}; +template<> +struct NBitMask::value> +{ + static const size_t value = size_t(-1); +}; + + + + + +template +struct MulOverflowMask +{ + static const size_t value = + ~NBitMask::value - CeilingLog2::value>::value; +}; +template<> struct MulOverflowMask<0> { }; +template<> struct MulOverflowMask<1> { static const size_t value = 0; }; +# 138 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TemplateLib.h" +template +struct And; + +template<> +struct And<> : public TrueType { }; + +template +struct And + : public Conditional, FalseType>::Type { }; + +} + +} +# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 2 +# 55 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" +extern "C" { +# 85 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" +__attribute__((weak)) __attribute__((visibility("default"))) void* moz_xmalloc(size_t size) + __attribute__ ((malloc, warn_unused_result)); + +__attribute__((weak)) __attribute__((visibility("default"))) void* moz_xcalloc(size_t nmemb, size_t size) + __attribute__ ((malloc, warn_unused_result)); + +__attribute__((weak)) __attribute__((visibility("default"))) void* moz_xrealloc(void* ptr, size_t size) + __attribute__ ((malloc, warn_unused_result)); + +__attribute__((weak)) __attribute__((visibility("default"))) char* moz_xstrdup(const char* str) + __attribute__ ((malloc, warn_unused_result)); + +__attribute__((weak)) __attribute__((visibility("default"))) size_t moz_malloc_usable_size(void *ptr); + +__attribute__((weak)) __attribute__((visibility("default"))) size_t moz_malloc_size_of(const void *ptr); + + +__attribute__((weak)) __attribute__((visibility("default"))) char* moz_xstrndup(const char* str, size_t strsize) + __attribute__ ((malloc, warn_unused_result)); + + + + +__attribute__((weak)) __attribute__((visibility("default"))) __attribute__ ((warn_unused_result)) +int moz_xposix_memalign(void **ptr, size_t alignment, size_t size); + +__attribute__((weak)) __attribute__((visibility("default"))) __attribute__ ((warn_unused_result)) +int moz_posix_memalign(void **ptr, size_t alignment, size_t size); + + + + +__attribute__((weak)) __attribute__((visibility("default"))) void* moz_xmemalign(size_t boundary, size_t size) + __attribute__ ((malloc, warn_unused_result)); + + + + +__attribute__((weak)) __attribute__((visibility("default"))) void* moz_xvalloc(size_t size) + __attribute__ ((malloc, warn_unused_result)); + + + + +} +# 190 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" +__attribute__((always_inline)) inline + +void* operator new(size_t size) throw(std::bad_alloc) +{ + return moz_xmalloc(size); +} + + __attribute__((always_inline)) inline +void* operator new(size_t size, const std::nothrow_t&) throw() +{ + return malloc(size); +} + + __attribute__((always_inline)) inline +void* operator new[](size_t size) throw(std::bad_alloc) +{ + return moz_xmalloc(size); +} + + __attribute__((always_inline)) inline +void* operator new[](size_t size, const std::nothrow_t&) throw() +{ + return malloc(size); +} + + __attribute__((always_inline)) inline +void operator delete(void* ptr) throw() +{ + return free(ptr); +} + + __attribute__((always_inline)) inline +void operator delete(void* ptr, const std::nothrow_t&) throw() +{ + return free(ptr); +} + + __attribute__((always_inline)) inline +void operator delete[](void* ptr) throw() +{ + return free(ptr); +} + + __attribute__((always_inline)) inline +void operator delete[](void* ptr, const std::nothrow_t&) throw() +{ + return free(ptr); +} +# 259 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" +__attribute__((always_inline)) inline +void* operator new(size_t size, const mozilla::fallible_t&) throw() +{ + return malloc(size); +} + +__attribute__((always_inline)) inline +void* operator new[](size_t size, const mozilla::fallible_t&) throw() +{ + return malloc(size); +} + +__attribute__((always_inline)) inline +void operator delete(void* ptr, const mozilla::fallible_t&) throw() +{ + free(ptr); +} + +__attribute__((always_inline)) inline +void operator delete[](void* ptr, const mozilla::fallible_t&) throw() +{ + free(ptr); +} + + + + + + + +class InfallibleAllocPolicy +{ +public: + template + T* maybe_pod_malloc(size_t aNumElems) + { + return pod_malloc(aNumElems); + } + + template + T* maybe_pod_calloc(size_t aNumElems) + { + return pod_calloc(aNumElems); + } + + template + T* maybe_pod_realloc(T* aPtr, size_t aOldSize, size_t aNewSize) + { + return pod_realloc(aPtr, aOldSize, aNewSize); + } + + template + T* pod_malloc(size_t aNumElems) + { + if (aNumElems & mozilla::tl::MulOverflowMask::value) { + reportAllocOverflow(); + } + return static_cast(moz_xmalloc(aNumElems * sizeof(T))); + } + + template + T* pod_calloc(size_t aNumElems) + { + return static_cast(moz_xcalloc(aNumElems, sizeof(T))); + } + + template + T* pod_realloc(T* aPtr, size_t aOldSize, size_t aNewSize) + { + if (aNewSize & mozilla::tl::MulOverflowMask::value) { + reportAllocOverflow(); + } + return static_cast(moz_xrealloc(aPtr, aNewSize * sizeof(T))); + } + + void free_(void* aPtr) + { + free(aPtr); + } + + void reportAllocOverflow() const + { + mozalloc_abort("alloc overflow"); + } + + bool checkSimulatedOOM() const + { + return true; + } +}; +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h" 2 + + + + + +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 +# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h" 2 + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCountType.h" 1 +# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCountType.h" +typedef uintptr_t MozRefCountType; +# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCountType.h" +typedef uint32_t MozExternalRefCountType; +# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h" 2 +# 231 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsError.h" 1 +# 127 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsError.h" +enum class nsresult : uint32_t +{ + + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" 1 + + + + NS_OK = 0, + + + + + NS_ERROR_BASE = 0xC1F30000, + + NS_ERROR_NOT_INITIALIZED = NS_ERROR_BASE + 1, + + NS_ERROR_ALREADY_INITIALIZED = NS_ERROR_BASE + 2, + + NS_ERROR_NOT_IMPLEMENTED = 0x80004001, + + NS_NOINTERFACE = 0x80004002, + NS_ERROR_NO_INTERFACE = NS_NOINTERFACE, + + NS_ERROR_ABORT = 0x80004004, + + NS_ERROR_FAILURE = 0x80004005, + + NS_ERROR_UNEXPECTED = 0x8000ffff, + + NS_ERROR_OUT_OF_MEMORY = 0x8007000e, + + NS_ERROR_ILLEGAL_VALUE = 0x80070057, + NS_ERROR_INVALID_ARG = NS_ERROR_ILLEGAL_VALUE, + NS_ERROR_INVALID_POINTER = NS_ERROR_INVALID_ARG, + NS_ERROR_NULL_POINTER = NS_ERROR_INVALID_ARG, + + NS_ERROR_NO_AGGREGATION = 0x80040110, + + NS_ERROR_NOT_AVAILABLE = 0x80040111, + + NS_ERROR_FACTORY_NOT_REGISTERED = 0x80040154, + + NS_ERROR_FACTORY_REGISTER_AGAIN = 0x80040155, + + NS_ERROR_FACTORY_NOT_LOADED = 0x800401f8, + + NS_ERROR_FACTORY_NO_SIGNATURE_SUPPORT = NS_ERROR_BASE + 0x101, + + NS_ERROR_FACTORY_EXISTS = NS_ERROR_BASE + 0x100, + + + + + + + + NS_ERROR_CANNOT_CONVERT_DATA = ((uint32_t)(1) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(1), + NS_ERROR_OBJECT_IS_IMMUTABLE = ((uint32_t)(1) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(2), + NS_ERROR_LOSS_OF_SIGNIFICANT_DATA = ((uint32_t)(1) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(3), + + NS_ERROR_NOT_SAME_THREAD = ((uint32_t)(1) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(4), + + + NS_ERROR_ILLEGAL_DURING_SHUTDOWN = ((uint32_t)(1) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(30), + NS_ERROR_SERVICE_NOT_AVAILABLE = ((uint32_t)(1) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(22), + + NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA = ((uint32_t)(0) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(1), + + NS_SUCCESS_INTERRUPTED_TRAVERSE = ((uint32_t)(0) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(2), + + NS_ERROR_SERVICE_NOT_FOUND = ((uint32_t)(0) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(22), + + NS_ERROR_SERVICE_IN_USE = ((uint32_t)(0) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(23), +# 80 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_BASE_STREAM_CLOSED = ((uint32_t)(1) << 31) | ((uint32_t)(2 + 0x45) << 16) | (uint32_t)(2), + + NS_BASE_STREAM_OSERROR = ((uint32_t)(1) << 31) | ((uint32_t)(2 + 0x45) << 16) | (uint32_t)(3), + + NS_BASE_STREAM_ILLEGAL_ARGS = ((uint32_t)(1) << 31) | ((uint32_t)(2 + 0x45) << 16) | (uint32_t)(4), + + NS_BASE_STREAM_NO_CONVERTER = ((uint32_t)(1) << 31) | ((uint32_t)(2 + 0x45) << 16) | (uint32_t)(5), + + NS_BASE_STREAM_BAD_CONVERSION = ((uint32_t)(1) << 31) | ((uint32_t)(2 + 0x45) << 16) | (uint32_t)(6), + NS_BASE_STREAM_WOULD_BLOCK = ((uint32_t)(1) << 31) | ((uint32_t)(2 + 0x45) << 16) | (uint32_t)(7), +# 98 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_GFX_PRINTER_NO_PRINTER_AVAILABLE = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(1), + + NS_ERROR_GFX_PRINTER_NAME_NOT_FOUND = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(2), + + NS_ERROR_GFX_PRINTER_COULD_NOT_OPEN_FILE = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(3), + + NS_ERROR_GFX_PRINTER_STARTDOC = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(4), + + NS_ERROR_GFX_PRINTER_ENDDOC = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(5), + + NS_ERROR_GFX_PRINTER_STARTPAGE = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(6), + + NS_ERROR_GFX_PRINTER_DOC_IS_BUSY = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(7), + + + NS_ERROR_GFX_CMAP_MALFORMED = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(51), +# 126 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_SUCCESS_EVENT_CONSUMED = ((uint32_t)(0) << 31) | ((uint32_t)(4 + 0x45) << 16) | (uint32_t)(1), + + + + + NS_SUCCESS_EVENT_HANDLED_ASYNCHRONOUSLY = ((uint32_t)(0) << 31) | ((uint32_t)(4 + 0x45) << 16) | (uint32_t)(2), +# 148 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_BINDING_SUCCEEDED = NS_OK, + + + NS_BINDING_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(1), + + NS_BINDING_ABORTED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(2), + + + + + + NS_BINDING_REDIRECTED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(3), + + + + + + NS_BINDING_RETARGETED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(4), + + + + + + NS_ERROR_MALFORMED_URI = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(10), + + + + NS_ERROR_IN_PROGRESS = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(15), + + + + + NS_ERROR_NO_CONTENT = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(17), + + NS_ERROR_UNKNOWN_PROTOCOL = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(18), + + + NS_ERROR_INVALID_CONTENT_ENCODING = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(27), + + + + NS_ERROR_CORRUPTED_CONTENT = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(29), + + + + NS_ERROR_INVALID_SIGNATURE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(58), + + + + NS_ERROR_FIRST_HEADER_FIELD_COMPONENT_EMPTY = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(34), + + + NS_ERROR_ALREADY_OPENED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(73), + + + + + NS_ERROR_ALREADY_CONNECTED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(11), + + NS_ERROR_NOT_CONNECTED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(12), + + + NS_ERROR_CONNECTION_REFUSED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(13), + + NS_ERROR_NET_TIMEOUT = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(14), + + + NS_ERROR_OFFLINE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(16), + + + + NS_ERROR_PORT_ACCESS_NOT_ALLOWED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(19), + + NS_ERROR_NET_RESET = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(20), + + NS_ERROR_NET_INTERRUPT = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(71), + + NS_ERROR_PROXY_CONNECTION_REFUSED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(72), + + NS_ERROR_NET_PARTIAL_TRANSFER = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(76), + + NS_ERROR_NET_INADEQUATE_SECURITY = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(82), + + + + + + NS_ERROR_NOT_RESUMABLE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(25), + + NS_ERROR_REDIRECT_LOOP = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(31), + + + NS_ERROR_ENTITY_CHANGED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(32), + + + + NS_ERROR_UNSAFE_CONTENT_TYPE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(74), + + + NS_ERROR_REMOTE_XUL = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(75), + + NS_ERROR_LOAD_SHOWED_ERRORPAGE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(77), + + + NS_ERROR_DOCSHELL_DYING = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(78), + + + + + NS_ERROR_FTP_LOGIN = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(21), + NS_ERROR_FTP_CWD = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(22), + NS_ERROR_FTP_PASV = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(23), + NS_ERROR_FTP_PWD = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(24), + NS_ERROR_FTP_LIST = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(28), + + + + + + NS_ERROR_UNKNOWN_HOST = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(30), + + + NS_ERROR_DNS_LOOKUP_QUEUE_FULL = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(33), + + + + NS_ERROR_UNKNOWN_PROXY_HOST = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(42), + + + + + + NS_ERROR_UNKNOWN_SOCKET_TYPE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(51), + + NS_ERROR_SOCKET_CREATE_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(52), + + NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(53), + + NS_ERROR_SOCKET_ADDRESS_IN_USE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(54), + + + NS_ERROR_CACHE_KEY_NOT_FOUND = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(61), + NS_ERROR_CACHE_DATA_IS_STREAM = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(62), + NS_ERROR_CACHE_DATA_IS_NOT_STREAM = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(63), + NS_ERROR_CACHE_WAIT_FOR_VALIDATION = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(64), + NS_ERROR_CACHE_ENTRY_DOOMED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(65), + NS_ERROR_CACHE_READ_ACCESS_DENIED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(66), + NS_ERROR_CACHE_WRITE_ACCESS_DENIED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(67), + NS_ERROR_CACHE_IN_USE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(68), + + + NS_ERROR_DOCUMENT_NOT_CACHED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(70), + + + + + + NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(80), + + NS_ERROR_HOST_IS_IP_ADDRESS = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(81), + + + + + + + + NS_SUCCESS_ADOPTED_DATA = ((uint32_t)(0) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(90), + + + NS_NET_STATUS_BEGIN_FTP_TRANSACTION = ((uint32_t)(0) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(27), + NS_NET_STATUS_END_FTP_TRANSACTION = ((uint32_t)(0) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(28), + + + + + NS_SUCCESS_AUTH_FINISHED = ((uint32_t)(0) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(40), + + + + + NS_NET_STATUS_READING = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(8), + NS_NET_STATUS_WRITING = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(9), + + + NS_NET_STATUS_RESOLVING_HOST = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(3), + NS_NET_STATUS_RESOLVED_HOST = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(11), + NS_NET_STATUS_CONNECTING_TO = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(7), + NS_NET_STATUS_CONNECTED_TO = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(4), + NS_NET_STATUS_TLS_HANDSHAKE_STARTING = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(12), + NS_NET_STATUS_TLS_HANDSHAKE_ENDED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(13), + NS_NET_STATUS_SENDING_TO = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(5), + NS_NET_STATUS_WAITING_FOR = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(10), + NS_NET_STATUS_RECEIVING_FROM = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(6), + + + + NS_ERROR_INTERCEPTION_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(100), + + + + NS_ERROR_HSTS_PRIMING_TIMEOUT = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(110), + + + + + + + + NS_ERROR_PLUGINS_PLUGINSNOTCHANGED = ((uint32_t)(1) << 31) | ((uint32_t)(7 + 0x45) << 16) | (uint32_t)(1000), + NS_ERROR_PLUGIN_DISABLED = ((uint32_t)(1) << 31) | ((uint32_t)(7 + 0x45) << 16) | (uint32_t)(1001), + NS_ERROR_PLUGIN_BLOCKLISTED = ((uint32_t)(1) << 31) | ((uint32_t)(7 + 0x45) << 16) | (uint32_t)(1002), + NS_ERROR_PLUGIN_TIME_RANGE_NOT_SUPPORTED = ((uint32_t)(1) << 31) | ((uint32_t)(7 + 0x45) << 16) | (uint32_t)(1003), + NS_ERROR_PLUGIN_CLICKTOPLAY = ((uint32_t)(1) << 31) | ((uint32_t)(7 + 0x45) << 16) | (uint32_t)(1004), + NS_PLUGIN_INIT_PENDING = ((uint32_t)(0) << 31) | ((uint32_t)(7 + 0x45) << 16) | (uint32_t)(1005), +# 371 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_TABLELAYOUT_CELL_NOT_FOUND = ((uint32_t)(0) << 31) | ((uint32_t)(8 + 0x45) << 16) | (uint32_t)(0), + + NS_POSITION_BEFORE_TABLE = ((uint32_t)(0) << 31) | ((uint32_t)(8 + 0x45) << 16) | (uint32_t)(3), + + + NS_STATE_PROPERTY_EXISTS = NS_OK, + + NS_STATE_PROPERTY_NOT_THERE = ((uint32_t)(0) << 31) | ((uint32_t)(8 + 0x45) << 16) | (uint32_t)(5), + + + + + + + + NS_ERROR_HTMLPARSER_CONTINUE = NS_OK, + + NS_ERROR_HTMLPARSER_EOF = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1000), + NS_ERROR_HTMLPARSER_UNKNOWN = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1001), + NS_ERROR_HTMLPARSER_CANTPROPAGATE = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1002), + NS_ERROR_HTMLPARSER_CONTEXTMISMATCH = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1003), + NS_ERROR_HTMLPARSER_BADFILENAME = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1004), + NS_ERROR_HTMLPARSER_BADURL = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1005), + NS_ERROR_HTMLPARSER_INVALIDPARSERCONTEXT = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1006), + NS_ERROR_HTMLPARSER_INTERRUPTED = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1007), + NS_ERROR_HTMLPARSER_BLOCK = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1008), + NS_ERROR_HTMLPARSER_BADTOKENIZER = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1009), + NS_ERROR_HTMLPARSER_BADATTRIBUTE = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1010), + NS_ERROR_HTMLPARSER_UNRESOLVEDDTD = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1011), + NS_ERROR_HTMLPARSER_MISPLACEDTABLECONTENT = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1012), + NS_ERROR_HTMLPARSER_BADDTD = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1013), + NS_ERROR_HTMLPARSER_BADCONTEXT = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1014), + NS_ERROR_HTMLPARSER_STOPPARSING = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1015), + NS_ERROR_HTMLPARSER_UNTERMINATEDSTRINGLITERAL = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1016), + NS_ERROR_HTMLPARSER_HIERARCHYTOODEEP = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1017), + NS_ERROR_HTMLPARSER_FAKE_ENDTAG = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1018), + NS_ERROR_HTMLPARSER_INVALID_COMMENT = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1019), + + NS_HTMLTOKENS_NOT_AN_ENTITY = ((uint32_t)(0) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(2000), + NS_HTMLPARSER_VALID_META_CHARSET = ((uint32_t)(0) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(3000), +# 420 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_RDF_ASSERTION_ACCEPTED = NS_OK, + + + NS_RDF_CURSOR_EMPTY = ((uint32_t)(0) << 31) | ((uint32_t)(10 + 0x45) << 16) | (uint32_t)(1), + + + NS_RDF_NO_VALUE = ((uint32_t)(0) << 31) | ((uint32_t)(10 + 0x45) << 16) | (uint32_t)(2), + + + + NS_RDF_ASSERTION_REJECTED = ((uint32_t)(0) << 31) | ((uint32_t)(10 + 0x45) << 16) | (uint32_t)(3), + + NS_RDF_STOP_VISIT = ((uint32_t)(0) << 31) | ((uint32_t)(10 + 0x45) << 16) | (uint32_t)(4), + + + + + + + + NS_ERROR_UCONV_NOCONV = ((uint32_t)(1) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(1), + NS_ERROR_UDEC_ILLEGALINPUT = ((uint32_t)(1) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(14), + + NS_SUCCESS_USING_FALLBACK_LOCALE = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(2), + NS_OK_UDEC_EXACTLENGTH = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(11), + NS_OK_UDEC_MOREINPUT = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(12), + NS_OK_UDEC_MOREOUTPUT = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(13), + NS_OK_UDEC_NOBOMFOUND = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(14), + NS_OK_UENC_EXACTLENGTH = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(33), + NS_OK_UENC_MOREOUTPUT = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(34), + NS_ERROR_UENC_NOMAPPING = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(35), + NS_OK_UENC_MOREINPUT = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(36), + + + NS_EXACT_LENGTH = NS_OK_UDEC_EXACTLENGTH, + NS_PARTIAL_MORE_INPUT = NS_OK_UDEC_MOREINPUT, + NS_PARTIAL_MORE_OUTPUT = NS_OK_UDEC_MOREOUTPUT, + NS_ERROR_ILLEGAL_INPUT = NS_ERROR_UDEC_ILLEGALINPUT, +# 466 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_FILE_UNRECOGNIZED_PATH = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(1), + NS_ERROR_FILE_UNRESOLVABLE_SYMLINK = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(2), + NS_ERROR_FILE_EXECUTION_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(3), + NS_ERROR_FILE_UNKNOWN_TYPE = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(4), + NS_ERROR_FILE_DESTINATION_NOT_DIR = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(5), + NS_ERROR_FILE_TARGET_DOES_NOT_EXIST = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(6), + NS_ERROR_FILE_COPY_OR_MOVE_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(7), + NS_ERROR_FILE_ALREADY_EXISTS = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(8), + NS_ERROR_FILE_INVALID_PATH = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(9), + NS_ERROR_FILE_DISK_FULL = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(10), + NS_ERROR_FILE_CORRUPTED = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(11), + NS_ERROR_FILE_NOT_DIRECTORY = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(12), + NS_ERROR_FILE_IS_DIRECTORY = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(13), + NS_ERROR_FILE_IS_LOCKED = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(14), + NS_ERROR_FILE_TOO_BIG = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(15), + NS_ERROR_FILE_NO_DEVICE_SPACE = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(16), + NS_ERROR_FILE_NAME_TOO_LONG = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(17), + NS_ERROR_FILE_NOT_FOUND = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(18), + NS_ERROR_FILE_READ_ONLY = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(19), + NS_ERROR_FILE_DIR_NOT_EMPTY = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(20), + NS_ERROR_FILE_ACCESS_DENIED = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(21), + + NS_SUCCESS_FILE_DIRECTORY_EMPTY = ((uint32_t)(0) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(1), + + NS_SUCCESS_AGGREGATE_RESULT = ((uint32_t)(0) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(2), +# 502 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_DOM_INDEX_SIZE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1), + NS_ERROR_DOM_HIERARCHY_REQUEST_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(3), + NS_ERROR_DOM_WRONG_DOCUMENT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(4), + NS_ERROR_DOM_INVALID_CHARACTER_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(5), + NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(7), + NS_ERROR_DOM_NOT_FOUND_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(8), + NS_ERROR_DOM_NOT_SUPPORTED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(9), + NS_ERROR_DOM_INUSE_ATTRIBUTE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(10), + NS_ERROR_DOM_INVALID_STATE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(11), + NS_ERROR_DOM_SYNTAX_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(12), + NS_ERROR_DOM_INVALID_MODIFICATION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(13), + NS_ERROR_DOM_NAMESPACE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(14), + NS_ERROR_DOM_INVALID_ACCESS_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(15), + NS_ERROR_DOM_TYPE_MISMATCH_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(17), + NS_ERROR_DOM_SECURITY_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(18), + NS_ERROR_DOM_NETWORK_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(19), + NS_ERROR_DOM_ABORT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(20), + NS_ERROR_DOM_URL_MISMATCH_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(21), + NS_ERROR_DOM_QUOTA_EXCEEDED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(22), + NS_ERROR_DOM_TIMEOUT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(23), + NS_ERROR_DOM_INVALID_NODE_TYPE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(24), + NS_ERROR_DOM_DATA_CLONE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(25), + + NS_ERROR_TYPE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(26), + NS_ERROR_RANGE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(27), + + NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(28), + NS_ERROR_DOM_INVALID_POINTER_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(29), + + NS_ERROR_DOM_UNKNOWN_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(30), + NS_ERROR_DOM_DATA_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(31), + NS_ERROR_DOM_OPERATION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(32), + + NS_ERROR_DOM_NOT_ALLOWED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(33), + + NS_ERROR_DOM_SECMAN_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1001), + NS_ERROR_DOM_WRONG_TYPE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1002), + NS_ERROR_DOM_NOT_OBJECT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1003), + NS_ERROR_DOM_NOT_XPC_OBJECT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1004), + NS_ERROR_DOM_NOT_NUMBER_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1005), + NS_ERROR_DOM_NOT_BOOLEAN_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1006), + NS_ERROR_DOM_NOT_FUNCTION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1007), + NS_ERROR_DOM_TOO_FEW_PARAMETERS_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1008), + NS_ERROR_DOM_BAD_DOCUMENT_DOMAIN = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1009), + NS_ERROR_DOM_PROP_ACCESS_DENIED = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1010), + NS_ERROR_DOM_XPCONNECT_ACCESS_DENIED = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1011), + NS_ERROR_DOM_BAD_URI = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1012), + NS_ERROR_DOM_RETVAL_UNDEFINED = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1013), + NS_ERROR_DOM_QUOTA_REACHED = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1014), + + + NS_ERROR_UNCATCHABLE_EXCEPTION = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1015), + + NS_ERROR_DOM_MALFORMED_URI = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1016), + NS_ERROR_DOM_INVALID_HEADER_NAME = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1017), + + NS_ERROR_DOM_INVALID_STATE_XHR_HAS_INVALID_CONTEXT = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1018), + NS_ERROR_DOM_INVALID_STATE_XHR_MUST_BE_OPENED = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1019), + NS_ERROR_DOM_INVALID_STATE_XHR_MUST_NOT_BE_SENDING = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1020), + NS_ERROR_DOM_INVALID_STATE_XHR_MUST_NOT_BE_LOADING_OR_DONE = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1021), + NS_ERROR_DOM_INVALID_STATE_XHR_HAS_WRONG_RESPONSETYPE_FOR_RESPONSEXML = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1022), + NS_ERROR_DOM_INVALID_STATE_XHR_HAS_WRONG_RESPONSETYPE_FOR_RESPONSETEXT = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1023), + NS_ERROR_DOM_INVALID_STATE_XHR_CHUNKED_RESPONSETYPES_UNSUPPORTED_FOR_SYNC = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1024), + NS_ERROR_DOM_INVALID_ACCESS_XHR_TIMEOUT_AND_RESPONSETYPE_UNSUPPORTED_FOR_SYNC = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1025), + + + + + + NS_SUCCESS_DOM_NO_OPERATION = ((uint32_t)(0) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1), + + + + + + + NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW = ((uint32_t)(0) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(2), + + + + + + + NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW_UNCATCHABLE = ((uint32_t)(0) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(3), + + + + + + + + NS_IMAGELIB_SUCCESS_LOAD_FINISHED = ((uint32_t)(0) << 31) | ((uint32_t)(15 + 0x45) << 16) | (uint32_t)(0), + NS_IMAGELIB_CHANGING_OWNER = ((uint32_t)(0) << 31) | ((uint32_t)(15 + 0x45) << 16) | (uint32_t)(1), + + NS_IMAGELIB_ERROR_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(15 + 0x45) << 16) | (uint32_t)(5), + NS_IMAGELIB_ERROR_NO_DECODER = ((uint32_t)(1) << 31) | ((uint32_t)(15 + 0x45) << 16) | (uint32_t)(6), + NS_IMAGELIB_ERROR_NOT_FINISHED = ((uint32_t)(1) << 31) | ((uint32_t)(15 + 0x45) << 16) | (uint32_t)(7), + NS_IMAGELIB_ERROR_NO_ENCODER = ((uint32_t)(1) << 31) | ((uint32_t)(15 + 0x45) << 16) | (uint32_t)(9), + + + + + + + + NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND = ((uint32_t)(0) << 31) | ((uint32_t)(17 + 0x45) << 16) | (uint32_t)(1), + NS_SUCCESS_EDITOR_FOUND_TARGET = ((uint32_t)(0) << 31) | ((uint32_t)(17 + 0x45) << 16) | (uint32_t)(2), + + + + + + + + NS_ERROR_XPC_NOT_ENOUGH_ARGS = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(1), + NS_ERROR_XPC_NEED_OUT_OBJECT = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(2), + NS_ERROR_XPC_CANT_SET_OUT_VAL = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(3), + NS_ERROR_XPC_NATIVE_RETURNED_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(4), + NS_ERROR_XPC_CANT_GET_INTERFACE_INFO = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(5), + NS_ERROR_XPC_CANT_GET_PARAM_IFACE_INFO = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(6), + NS_ERROR_XPC_CANT_GET_METHOD_INFO = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(7), + NS_ERROR_XPC_UNEXPECTED = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(8), + NS_ERROR_XPC_BAD_CONVERT_JS = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(9), + NS_ERROR_XPC_BAD_CONVERT_NATIVE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(10), + NS_ERROR_XPC_BAD_CONVERT_JS_NULL_REF = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(11), + NS_ERROR_XPC_BAD_OP_ON_WN_PROTO = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(12), + NS_ERROR_XPC_CANT_CONVERT_WN_TO_FUN = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(13), + NS_ERROR_XPC_CANT_DEFINE_PROP_ON_WN = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(14), + NS_ERROR_XPC_CANT_WATCH_WN_STATIC = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(15), + NS_ERROR_XPC_CANT_EXPORT_WN_STATIC = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(16), + NS_ERROR_XPC_SCRIPTABLE_CALL_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(17), + NS_ERROR_XPC_SCRIPTABLE_CTOR_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(18), + NS_ERROR_XPC_CANT_CALL_WO_SCRIPTABLE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(19), + NS_ERROR_XPC_CANT_CTOR_WO_SCRIPTABLE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(20), + NS_ERROR_XPC_CI_RETURNED_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(21), + NS_ERROR_XPC_GS_RETURNED_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(22), + NS_ERROR_XPC_BAD_CID = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(23), + NS_ERROR_XPC_BAD_IID = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(24), + NS_ERROR_XPC_CANT_CREATE_WN = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(25), + NS_ERROR_XPC_JS_THREW_EXCEPTION = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(26), + NS_ERROR_XPC_JS_THREW_NATIVE_OBJECT = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(27), + NS_ERROR_XPC_JS_THREW_JS_OBJECT = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(28), + NS_ERROR_XPC_JS_THREW_NULL = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(29), + NS_ERROR_XPC_JS_THREW_STRING = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(30), + NS_ERROR_XPC_JS_THREW_NUMBER = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(31), + NS_ERROR_XPC_JAVASCRIPT_ERROR = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(32), + NS_ERROR_XPC_JAVASCRIPT_ERROR_WITH_DETAILS = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(33), + NS_ERROR_XPC_CANT_CONVERT_PRIMITIVE_TO_ARRAY = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(34), + NS_ERROR_XPC_CANT_CONVERT_OBJECT_TO_ARRAY = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(35), + NS_ERROR_XPC_NOT_ENOUGH_ELEMENTS_IN_ARRAY = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(36), + NS_ERROR_XPC_CANT_GET_ARRAY_INFO = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(37), + NS_ERROR_XPC_NOT_ENOUGH_CHARS_IN_STRING = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(38), + NS_ERROR_XPC_SECURITY_MANAGER_VETO = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(39), + NS_ERROR_XPC_INTERFACE_NOT_SCRIPTABLE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(40), + NS_ERROR_XPC_INTERFACE_NOT_FROM_NSISUPPORTS = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(41), + NS_ERROR_XPC_CANT_GET_JSOBJECT_OF_DOM_OBJECT = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(42), + NS_ERROR_XPC_CANT_SET_READ_ONLY_CONSTANT = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(43), + NS_ERROR_XPC_CANT_SET_READ_ONLY_ATTRIBUTE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(44), + NS_ERROR_XPC_CANT_SET_READ_ONLY_METHOD = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(45), + NS_ERROR_XPC_CANT_ADD_PROP_TO_WRAPPED_NATIVE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(46), + NS_ERROR_XPC_CALL_TO_SCRIPTABLE_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(47), + NS_ERROR_XPC_JSOBJECT_HAS_NO_FUNCTION_NAMED = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(48), + NS_ERROR_XPC_BAD_ID_STRING = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(49), + NS_ERROR_XPC_BAD_INITIALIZER_NAME = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(50), + NS_ERROR_XPC_HAS_BEEN_SHUTDOWN = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(51), + NS_ERROR_XPC_CANT_MODIFY_PROP_ON_WN = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(52), + NS_ERROR_XPC_BAD_CONVERT_JS_ZERO_ISNOT_NULL = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(53), + NS_ERROR_XPC_CANT_PASS_CPOW_TO_NATIVE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(54), +# 678 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_LAUNCHED_CHILD_PROCESS = ((uint32_t)(1) << 31) | ((uint32_t)(19 + 0x45) << 16) | (uint32_t)(200), +# 687 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_CSP_FORM_ACTION_VIOLATION = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(98), + NS_ERROR_CSP_FRAME_ANCESTOR_VIOLATION = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(99), + + + NS_ERROR_SRI_CORRUPT = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(200), + NS_ERROR_SRI_DISABLED = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(201), + NS_ERROR_SRI_NOT_ELIGIBLE = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(202), + NS_ERROR_SRI_UNEXPECTED_HASH_TYPE = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(203), + NS_ERROR_SRI_IMPORT = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(204), + + + + NS_ERROR_CMS_VERIFY_NOT_SIGNED = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1024), + NS_ERROR_CMS_VERIFY_NO_CONTENT_INFO = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1025), + NS_ERROR_CMS_VERIFY_BAD_DIGEST = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1026), + NS_ERROR_CMS_VERIFY_NOCERT = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1028), + NS_ERROR_CMS_VERIFY_UNTRUSTED = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1029), + NS_ERROR_CMS_VERIFY_ERROR_UNVERIFIED = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1031), + NS_ERROR_CMS_VERIFY_ERROR_PROCESSING = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1032), + NS_ERROR_CMS_VERIFY_BAD_SIGNATURE = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1033), + NS_ERROR_CMS_VERIFY_DIGEST_MISMATCH = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1034), + NS_ERROR_CMS_VERIFY_UNKNOWN_ALGO = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1035), + NS_ERROR_CMS_VERIFY_UNSUPPORTED_ALGO = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1036), + NS_ERROR_CMS_VERIFY_MALFORMED_SIGNATURE = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1037), + NS_ERROR_CMS_VERIFY_HEADER_MISMATCH = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1038), + NS_ERROR_CMS_VERIFY_NOT_YET_ATTEMPTED = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1039), + NS_ERROR_CMS_VERIFY_CERT_WITHOUT_ADDRESS = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1040), + NS_ERROR_CMS_ENCRYPT_NO_BULK_ALG = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1056), + NS_ERROR_CMS_ENCRYPT_INCOMPLETE = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1057), +# 724 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_DOM_INVALID_EXPRESSION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(22 + 0x45) << 16) | (uint32_t)(51), + NS_ERROR_DOM_TYPE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(22 + 0x45) << 16) | (uint32_t)(52), + + + + + + + + NS_ERROR_WONT_HANDLE_CONTENT = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(1), + + + NS_ERROR_MALWARE_URI = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(30), + NS_ERROR_PHISHING_URI = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(31), + NS_ERROR_TRACKING_URI = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(34), + NS_ERROR_UNWANTED_URI = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(35), + NS_ERROR_BLOCKED_URI = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(37), + + + NS_ERROR_SAVE_LINK_AS_TIMEOUT = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(32), + + + NS_ERROR_PARSED_DATA_CACHED = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(33), + + + + NS_REFRESHURI_HEADER_FOUND = ((uint32_t)(0) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(2), +# 759 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_IMAGE_SRC_CHANGED = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(4), + NS_ERROR_IMAGE_BLOCKED = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(5), + + NS_ERROR_CONTENT_BLOCKED = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(6), + NS_ERROR_CONTENT_BLOCKED_SHOW_ALT = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(7), + + NS_PROPTABLE_PROP_NOT_THERE = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(10), + + NS_ERROR_XBL_BLOCKED = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(15), + + NS_ERROR_CONTENT_CRASHED = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(16), + + + NS_HTML_STYLE_PROPERTY_NOT_THERE = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(2), + NS_CONTENT_BLOCKED = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(8), + NS_CONTENT_BLOCKED_SHOW_ALT = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(9), + NS_PROPTABLE_PROP_OVERWRITTEN = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(11), + + NS_FINDBROADCASTER_NOT_FOUND = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(12), + NS_FINDBROADCASTER_FOUND = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(13), + NS_FINDBROADCASTER_AWAIT_OVERLAYS = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(14), + + + + + + + + NS_ERROR_XPATH_INVALID_ARG = NS_ERROR_INVALID_ARG, + + NS_ERROR_XSLT_PARSE_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(1), + NS_ERROR_XPATH_PARSE_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(2), + NS_ERROR_XSLT_ALREADY_SET = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(3), + NS_ERROR_XSLT_EXECUTION_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(4), + NS_ERROR_XPATH_UNKNOWN_FUNCTION = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(5), + NS_ERROR_XSLT_BAD_RECURSION = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(6), + NS_ERROR_XSLT_BAD_VALUE = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(7), + NS_ERROR_XSLT_NODESET_EXPECTED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(8), + NS_ERROR_XSLT_ABORTED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(9), + NS_ERROR_XSLT_NETWORK_ERROR = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(10), + NS_ERROR_XSLT_WRONG_MIME_TYPE = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(11), + NS_ERROR_XSLT_LOAD_RECURSION = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(12), + NS_ERROR_XPATH_BAD_ARGUMENT_COUNT = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(13), + NS_ERROR_XPATH_BAD_EXTENSION_FUNCTION = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(14), + NS_ERROR_XPATH_PAREN_EXPECTED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(15), + NS_ERROR_XPATH_INVALID_AXIS = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(16), + NS_ERROR_XPATH_NO_NODE_TYPE_TEST = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(17), + NS_ERROR_XPATH_BRACKET_EXPECTED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(18), + NS_ERROR_XPATH_INVALID_VAR_NAME = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(19), + NS_ERROR_XPATH_UNEXPECTED_END = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(20), + NS_ERROR_XPATH_OPERATOR_EXPECTED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(21), + NS_ERROR_XPATH_UNCLOSED_LITERAL = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(22), + NS_ERROR_XPATH_BAD_COLON = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(23), + NS_ERROR_XPATH_BAD_BANG = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(24), + NS_ERROR_XPATH_ILLEGAL_CHAR = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(25), + NS_ERROR_XPATH_BINARY_EXPECTED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(26), + NS_ERROR_XSLT_LOAD_BLOCKED_ERROR = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(27), + NS_ERROR_XPATH_INVALID_EXPRESSION_EVALUATED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(28), + NS_ERROR_XPATH_UNBALANCED_CURLY_BRACE = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(29), + NS_ERROR_XSLT_BAD_NODE_NAME = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(30), + NS_ERROR_XSLT_VAR_ALREADY_SET = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(31), + NS_ERROR_XSLT_CALL_TO_KEY_NOT_ALLOWED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(32), + + NS_XSLT_GET_NEW_HANDLER = ((uint32_t)(0) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(1), +# 831 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_TRANSPORT_INIT = ((uint32_t)(1) << 31) | ((uint32_t)(28 + 0x45) << 16) | (uint32_t)(1), + + NS_ERROR_DUPLICATE_HANDLE = ((uint32_t)(1) << 31) | ((uint32_t)(28 + 0x45) << 16) | (uint32_t)(2), + + NS_ERROR_BRIDGE_OPEN_PARENT = ((uint32_t)(1) << 31) | ((uint32_t)(28 + 0x45) << 16) | (uint32_t)(3), + + NS_ERROR_BRIDGE_OPEN_CHILD = ((uint32_t)(1) << 31) | ((uint32_t)(28 + 0x45) << 16) | (uint32_t)(4), + + + + + + + + NS_ERROR_DOM_SVG_WRONG_TYPE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(29 + 0x45) << 16) | (uint32_t)(0), + + NS_ERROR_DOM_SVG_MATRIX_NOT_INVERTABLE = ((uint32_t)(1) << 31) | ((uint32_t)(29 + 0x45) << 16) | (uint32_t)(2), +# 863 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_STORAGE_BUSY = ((uint32_t)(1) << 31) | ((uint32_t)(30 + 0x45) << 16) | (uint32_t)(1), + NS_ERROR_STORAGE_IOERR = ((uint32_t)(1) << 31) | ((uint32_t)(30 + 0x45) << 16) | (uint32_t)(2), + NS_ERROR_STORAGE_CONSTRAINT = ((uint32_t)(1) << 31) | ((uint32_t)(30 + 0x45) << 16) | (uint32_t)(3), + + + + + + + + NS_ERROR_DOM_FILE_NOT_FOUND_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(32 + 0x45) << 16) | (uint32_t)(0), + NS_ERROR_DOM_FILE_NOT_READABLE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(32 + 0x45) << 16) | (uint32_t)(1), + NS_ERROR_DOM_FILE_ABORT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(32 + 0x45) << 16) | (uint32_t)(2), +# 884 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(1), + NS_ERROR_DOM_INDEXEDDB_NOT_FOUND_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(3), + NS_ERROR_DOM_INDEXEDDB_CONSTRAINT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(4), + NS_ERROR_DOM_INDEXEDDB_DATA_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(5), + NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(6), + NS_ERROR_DOM_INDEXEDDB_TRANSACTION_INACTIVE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(7), + NS_ERROR_DOM_INDEXEDDB_ABORT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(8), + NS_ERROR_DOM_INDEXEDDB_READ_ONLY_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(9), + NS_ERROR_DOM_INDEXEDDB_TIMEOUT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(10), + NS_ERROR_DOM_INDEXEDDB_QUOTA_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(11), + NS_ERROR_DOM_INDEXEDDB_VERSION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(12), + NS_ERROR_DOM_INDEXEDDB_RECOVERABLE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(1001), + + + + + + + + NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(34 + 0x45) << 16) | (uint32_t)(1), + NS_ERROR_DOM_FILEHANDLE_NOT_ALLOWED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(34 + 0x45) << 16) | (uint32_t)(2), + NS_ERROR_DOM_FILEHANDLE_INACTIVE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(34 + 0x45) << 16) | (uint32_t)(3), + NS_ERROR_DOM_FILEHANDLE_ABORT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(34 + 0x45) << 16) | (uint32_t)(4), + NS_ERROR_DOM_FILEHANDLE_READ_ONLY_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(34 + 0x45) << 16) | (uint32_t)(5), + NS_ERROR_DOM_FILEHANDLE_QUOTA_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(34 + 0x45) << 16) | (uint32_t)(6), + + + + + + + NS_ERROR_SIGNED_JAR_NOT_SIGNED = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(1), + NS_ERROR_SIGNED_JAR_MODIFIED_ENTRY = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(2), + NS_ERROR_SIGNED_JAR_UNSIGNED_ENTRY = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(3), + NS_ERROR_SIGNED_JAR_ENTRY_MISSING = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(4), + NS_ERROR_SIGNED_JAR_WRONG_SIGNATURE = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(5), + NS_ERROR_SIGNED_JAR_ENTRY_TOO_LARGE = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(6), + NS_ERROR_SIGNED_JAR_ENTRY_INVALID = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(7), + NS_ERROR_SIGNED_JAR_MANIFEST_INVALID = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(8), + + + + + + + NS_ERROR_DOM_FILESYSTEM_INVALID_PATH_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(36 + 0x45) << 16) | (uint32_t)(1), + NS_ERROR_DOM_FILESYSTEM_INVALID_MODIFICATION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(36 + 0x45) << 16) | (uint32_t)(2), + NS_ERROR_DOM_FILESYSTEM_NO_MODIFICATION_ALLOWED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(36 + 0x45) << 16) | (uint32_t)(3), + NS_ERROR_DOM_FILESYSTEM_PATH_EXISTS_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(36 + 0x45) << 16) | (uint32_t)(4), + NS_ERROR_DOM_FILESYSTEM_TYPE_MISMATCH_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(36 + 0x45) << 16) | (uint32_t)(5), + NS_ERROR_DOM_FILESYSTEM_UNKNOWN_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(36 + 0x45) << 16) | (uint32_t)(6), + + + + + + + NS_ERROR_SIGNED_APP_MANIFEST_INVALID = ((uint32_t)(1) << 31) | ((uint32_t)(38 + 0x45) << 16) | (uint32_t)(1), + + + + + + + NS_ERROR_DOM_ANIM_MISSING_PROPS_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(39 + 0x45) << 16) | (uint32_t)(1), + + + + + + + NS_ERROR_DOM_PUSH_INVALID_REGISTRATION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(40 + 0x45) << 16) | (uint32_t)(1), + NS_ERROR_DOM_PUSH_DENIED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(40 + 0x45) << 16) | (uint32_t)(2), + NS_ERROR_DOM_PUSH_ABORT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(40 + 0x45) << 16) | (uint32_t)(3), + NS_ERROR_DOM_PUSH_SERVICE_UNREACHABLE = ((uint32_t)(1) << 31) | ((uint32_t)(40 + 0x45) << 16) | (uint32_t)(4), + NS_ERROR_DOM_PUSH_INVALID_KEY_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(40 + 0x45) << 16) | (uint32_t)(5), + NS_ERROR_DOM_PUSH_MISMATCHED_KEY_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(40 + 0x45) << 16) | (uint32_t)(6), + + + + + + + + NS_ERROR_DOM_MEDIA_ABORT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(1), + NS_ERROR_DOM_MEDIA_NOT_ALLOWED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(2), + NS_ERROR_DOM_MEDIA_NOT_SUPPORTED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(3), + + + NS_ERROR_DOM_MEDIA_DECODE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(4), + NS_ERROR_DOM_MEDIA_FATAL_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(5), + NS_ERROR_DOM_MEDIA_METADATA_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(6), + NS_ERROR_DOM_MEDIA_OVERFLOW_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(7), + NS_ERROR_DOM_MEDIA_END_OF_STREAM = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(8), + NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(9), + NS_ERROR_DOM_MEDIA_CANCELED = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(10), + NS_ERROR_DOM_MEDIA_MEDIASINK_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(11), + NS_ERROR_DOM_MEDIA_DEMUXER_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(12), + NS_ERROR_DOM_MEDIA_CDM_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(13), + NS_ERROR_DOM_MEDIA_NEED_NEW_DECODER = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(14), + NS_ERROR_DOM_MEDIA_INITIALIZING_DECODER = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(15), + + + NS_ERROR_DOM_MEDIA_CUBEB_INITIALIZATION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(101), + + + + + + + NS_ERROR_UC_UPDATE_UNKNOWN = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(1), + NS_ERROR_UC_UPDATE_DUPLICATE_PREFIX = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(2), + NS_ERROR_UC_UPDATE_INFINITE_LOOP = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(3), + NS_ERROR_UC_UPDATE_WRONG_REMOVAL_INDICES = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(4), + NS_ERROR_UC_UPDATE_CHECKSUM_MISMATCH = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(5), + NS_ERROR_UC_UPDATE_MISSING_CHECKSUM = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(6), + NS_ERROR_UC_UPDATE_SHUTDOWNING = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(7), + NS_ERROR_UC_UPDATE_TABLE_NOT_FOUND = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(8), + NS_ERROR_UC_UPDATE_BUILD_PREFIX_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(9), + NS_ERROR_UC_UPDATE_FAIL_TO_WRITE_DISK = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(10), + NS_ERROR_UC_UPDATE_PROTOCOL_PARSER_ERROR = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(11), + + + + + + + + NS_ERROR_INTERNAL_ERRORRESULT_JS_EXCEPTION = ((uint32_t)(1) << 31) | ((uint32_t)(43 + 0x45) << 16) | (uint32_t)(1), + + NS_ERROR_INTERNAL_ERRORRESULT_DOMEXCEPTION = ((uint32_t)(1) << 31) | ((uint32_t)(43 + 0x45) << 16) | (uint32_t)(2), + + NS_ERROR_INTERNAL_ERRORRESULT_EXCEPTION_ON_JSCONTEXT = ((uint32_t)(1) << 31) | ((uint32_t)(43 + 0x45) << 16) | (uint32_t)(3), + + NS_ERROR_INTERNAL_ERRORRESULT_TYPEERROR = ((uint32_t)(1) << 31) | ((uint32_t)(43 + 0x45) << 16) | (uint32_t)(4), + + NS_ERROR_INTERNAL_ERRORRESULT_RANGEERROR = ((uint32_t)(1) << 31) | ((uint32_t)(43 + 0x45) << 16) | (uint32_t)(5), +# 1029 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_DOWNLOAD_COMPLETE = ((uint32_t)(1) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(1), + + + + NS_ERROR_DOWNLOAD_NOT_PARTIAL = ((uint32_t)(1) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(2), + NS_ERROR_UNORM_MOREOUTPUT = ((uint32_t)(1) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(33), + + NS_ERROR_DOCSHELL_REQUEST_REJECTED = ((uint32_t)(1) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(1001), + + + + + NS_ERROR_DOCUMENT_IS_PRINTMODE = ((uint32_t)(1) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(2001), + + NS_SUCCESS_DONT_FIXUP = ((uint32_t)(0) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(1), + + + + NS_SUCCESS_RESTART_APP = ((uint32_t)(0) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(1), + NS_SUCCESS_RESTART_APP_NOT_SAME_PROFILE = ((uint32_t)(0) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(3), + NS_SUCCESS_UNORM_NOTFOUND = ((uint32_t)(0) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(17), + + + + + NS_ERROR_NOT_IN_TREE = ((uint32_t)(1) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(38), + + + NS_OK_NO_NAME_CLAUSE_HANDLED = ((uint32_t)(0) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(34) +# 132 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsError.h" 2 + +}; + + + + + +const nsresult + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" 1 + + + + NS_OK = nsresult::NS_OK, + + + + + NS_ERROR_BASE = nsresult::NS_ERROR_BASE, + + NS_ERROR_NOT_INITIALIZED = nsresult::NS_ERROR_NOT_INITIALIZED, + + NS_ERROR_ALREADY_INITIALIZED = nsresult::NS_ERROR_ALREADY_INITIALIZED, + + NS_ERROR_NOT_IMPLEMENTED = nsresult::NS_ERROR_NOT_IMPLEMENTED, + + NS_NOINTERFACE = nsresult::NS_NOINTERFACE, + NS_ERROR_NO_INTERFACE = nsresult::NS_ERROR_NO_INTERFACE, + + NS_ERROR_ABORT = nsresult::NS_ERROR_ABORT, + + NS_ERROR_FAILURE = nsresult::NS_ERROR_FAILURE, + + NS_ERROR_UNEXPECTED = nsresult::NS_ERROR_UNEXPECTED, + + NS_ERROR_OUT_OF_MEMORY = nsresult::NS_ERROR_OUT_OF_MEMORY, + + NS_ERROR_ILLEGAL_VALUE = nsresult::NS_ERROR_ILLEGAL_VALUE, + NS_ERROR_INVALID_ARG = nsresult::NS_ERROR_INVALID_ARG, + NS_ERROR_INVALID_POINTER = nsresult::NS_ERROR_INVALID_POINTER, + NS_ERROR_NULL_POINTER = nsresult::NS_ERROR_NULL_POINTER, + + NS_ERROR_NO_AGGREGATION = nsresult::NS_ERROR_NO_AGGREGATION, + + NS_ERROR_NOT_AVAILABLE = nsresult::NS_ERROR_NOT_AVAILABLE, + + NS_ERROR_FACTORY_NOT_REGISTERED = nsresult::NS_ERROR_FACTORY_NOT_REGISTERED, + + NS_ERROR_FACTORY_REGISTER_AGAIN = nsresult::NS_ERROR_FACTORY_REGISTER_AGAIN, + + NS_ERROR_FACTORY_NOT_LOADED = nsresult::NS_ERROR_FACTORY_NOT_LOADED, + + NS_ERROR_FACTORY_NO_SIGNATURE_SUPPORT = nsresult::NS_ERROR_FACTORY_NO_SIGNATURE_SUPPORT, + + NS_ERROR_FACTORY_EXISTS = nsresult::NS_ERROR_FACTORY_EXISTS, + + + + + + + + NS_ERROR_CANNOT_CONVERT_DATA = nsresult::NS_ERROR_CANNOT_CONVERT_DATA, + NS_ERROR_OBJECT_IS_IMMUTABLE = nsresult::NS_ERROR_OBJECT_IS_IMMUTABLE, + NS_ERROR_LOSS_OF_SIGNIFICANT_DATA = nsresult::NS_ERROR_LOSS_OF_SIGNIFICANT_DATA, + + NS_ERROR_NOT_SAME_THREAD = nsresult::NS_ERROR_NOT_SAME_THREAD, + + + NS_ERROR_ILLEGAL_DURING_SHUTDOWN = nsresult::NS_ERROR_ILLEGAL_DURING_SHUTDOWN, + NS_ERROR_SERVICE_NOT_AVAILABLE = nsresult::NS_ERROR_SERVICE_NOT_AVAILABLE, + + NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA = nsresult::NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA, + + NS_SUCCESS_INTERRUPTED_TRAVERSE = nsresult::NS_SUCCESS_INTERRUPTED_TRAVERSE, + + NS_ERROR_SERVICE_NOT_FOUND = nsresult::NS_ERROR_SERVICE_NOT_FOUND, + + NS_ERROR_SERVICE_IN_USE = nsresult::NS_ERROR_SERVICE_IN_USE, +# 80 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_BASE_STREAM_CLOSED = nsresult::NS_BASE_STREAM_CLOSED, + + NS_BASE_STREAM_OSERROR = nsresult::NS_BASE_STREAM_OSERROR, + + NS_BASE_STREAM_ILLEGAL_ARGS = nsresult::NS_BASE_STREAM_ILLEGAL_ARGS, + + NS_BASE_STREAM_NO_CONVERTER = nsresult::NS_BASE_STREAM_NO_CONVERTER, + + NS_BASE_STREAM_BAD_CONVERSION = nsresult::NS_BASE_STREAM_BAD_CONVERSION, + NS_BASE_STREAM_WOULD_BLOCK = nsresult::NS_BASE_STREAM_WOULD_BLOCK, +# 98 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_GFX_PRINTER_NO_PRINTER_AVAILABLE = nsresult::NS_ERROR_GFX_PRINTER_NO_PRINTER_AVAILABLE, + + NS_ERROR_GFX_PRINTER_NAME_NOT_FOUND = nsresult::NS_ERROR_GFX_PRINTER_NAME_NOT_FOUND, + + NS_ERROR_GFX_PRINTER_COULD_NOT_OPEN_FILE = nsresult::NS_ERROR_GFX_PRINTER_COULD_NOT_OPEN_FILE, + + NS_ERROR_GFX_PRINTER_STARTDOC = nsresult::NS_ERROR_GFX_PRINTER_STARTDOC, + + NS_ERROR_GFX_PRINTER_ENDDOC = nsresult::NS_ERROR_GFX_PRINTER_ENDDOC, + + NS_ERROR_GFX_PRINTER_STARTPAGE = nsresult::NS_ERROR_GFX_PRINTER_STARTPAGE, + + NS_ERROR_GFX_PRINTER_DOC_IS_BUSY = nsresult::NS_ERROR_GFX_PRINTER_DOC_IS_BUSY, + + + NS_ERROR_GFX_CMAP_MALFORMED = nsresult::NS_ERROR_GFX_CMAP_MALFORMED, +# 126 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_SUCCESS_EVENT_CONSUMED = nsresult::NS_SUCCESS_EVENT_CONSUMED, + + + + + NS_SUCCESS_EVENT_HANDLED_ASYNCHRONOUSLY = nsresult::NS_SUCCESS_EVENT_HANDLED_ASYNCHRONOUSLY, +# 148 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_BINDING_SUCCEEDED = nsresult::NS_BINDING_SUCCEEDED, + + + NS_BINDING_FAILED = nsresult::NS_BINDING_FAILED, + + NS_BINDING_ABORTED = nsresult::NS_BINDING_ABORTED, + + + + + + NS_BINDING_REDIRECTED = nsresult::NS_BINDING_REDIRECTED, + + + + + + NS_BINDING_RETARGETED = nsresult::NS_BINDING_RETARGETED, + + + + + + NS_ERROR_MALFORMED_URI = nsresult::NS_ERROR_MALFORMED_URI, + + + + NS_ERROR_IN_PROGRESS = nsresult::NS_ERROR_IN_PROGRESS, + + + + + NS_ERROR_NO_CONTENT = nsresult::NS_ERROR_NO_CONTENT, + + NS_ERROR_UNKNOWN_PROTOCOL = nsresult::NS_ERROR_UNKNOWN_PROTOCOL, + + + NS_ERROR_INVALID_CONTENT_ENCODING = nsresult::NS_ERROR_INVALID_CONTENT_ENCODING, + + + + NS_ERROR_CORRUPTED_CONTENT = nsresult::NS_ERROR_CORRUPTED_CONTENT, + + + + NS_ERROR_INVALID_SIGNATURE = nsresult::NS_ERROR_INVALID_SIGNATURE, + + + + NS_ERROR_FIRST_HEADER_FIELD_COMPONENT_EMPTY = nsresult::NS_ERROR_FIRST_HEADER_FIELD_COMPONENT_EMPTY, + + + NS_ERROR_ALREADY_OPENED = nsresult::NS_ERROR_ALREADY_OPENED, + + + + + NS_ERROR_ALREADY_CONNECTED = nsresult::NS_ERROR_ALREADY_CONNECTED, + + NS_ERROR_NOT_CONNECTED = nsresult::NS_ERROR_NOT_CONNECTED, + + + NS_ERROR_CONNECTION_REFUSED = nsresult::NS_ERROR_CONNECTION_REFUSED, + + NS_ERROR_NET_TIMEOUT = nsresult::NS_ERROR_NET_TIMEOUT, + + + NS_ERROR_OFFLINE = nsresult::NS_ERROR_OFFLINE, + + + + NS_ERROR_PORT_ACCESS_NOT_ALLOWED = nsresult::NS_ERROR_PORT_ACCESS_NOT_ALLOWED, + + NS_ERROR_NET_RESET = nsresult::NS_ERROR_NET_RESET, + + NS_ERROR_NET_INTERRUPT = nsresult::NS_ERROR_NET_INTERRUPT, + + NS_ERROR_PROXY_CONNECTION_REFUSED = nsresult::NS_ERROR_PROXY_CONNECTION_REFUSED, + + NS_ERROR_NET_PARTIAL_TRANSFER = nsresult::NS_ERROR_NET_PARTIAL_TRANSFER, + + NS_ERROR_NET_INADEQUATE_SECURITY = nsresult::NS_ERROR_NET_INADEQUATE_SECURITY, + + + + + + NS_ERROR_NOT_RESUMABLE = nsresult::NS_ERROR_NOT_RESUMABLE, + + NS_ERROR_REDIRECT_LOOP = nsresult::NS_ERROR_REDIRECT_LOOP, + + + NS_ERROR_ENTITY_CHANGED = nsresult::NS_ERROR_ENTITY_CHANGED, + + + + NS_ERROR_UNSAFE_CONTENT_TYPE = nsresult::NS_ERROR_UNSAFE_CONTENT_TYPE, + + + NS_ERROR_REMOTE_XUL = nsresult::NS_ERROR_REMOTE_XUL, + + NS_ERROR_LOAD_SHOWED_ERRORPAGE = nsresult::NS_ERROR_LOAD_SHOWED_ERRORPAGE, + + + NS_ERROR_DOCSHELL_DYING = nsresult::NS_ERROR_DOCSHELL_DYING, + + + + + NS_ERROR_FTP_LOGIN = nsresult::NS_ERROR_FTP_LOGIN, + NS_ERROR_FTP_CWD = nsresult::NS_ERROR_FTP_CWD, + NS_ERROR_FTP_PASV = nsresult::NS_ERROR_FTP_PASV, + NS_ERROR_FTP_PWD = nsresult::NS_ERROR_FTP_PWD, + NS_ERROR_FTP_LIST = nsresult::NS_ERROR_FTP_LIST, + + + + + + NS_ERROR_UNKNOWN_HOST = nsresult::NS_ERROR_UNKNOWN_HOST, + + + NS_ERROR_DNS_LOOKUP_QUEUE_FULL = nsresult::NS_ERROR_DNS_LOOKUP_QUEUE_FULL, + + + + NS_ERROR_UNKNOWN_PROXY_HOST = nsresult::NS_ERROR_UNKNOWN_PROXY_HOST, + + + + + + NS_ERROR_UNKNOWN_SOCKET_TYPE = nsresult::NS_ERROR_UNKNOWN_SOCKET_TYPE, + + NS_ERROR_SOCKET_CREATE_FAILED = nsresult::NS_ERROR_SOCKET_CREATE_FAILED, + + NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED = nsresult::NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED, + + NS_ERROR_SOCKET_ADDRESS_IN_USE = nsresult::NS_ERROR_SOCKET_ADDRESS_IN_USE, + + + NS_ERROR_CACHE_KEY_NOT_FOUND = nsresult::NS_ERROR_CACHE_KEY_NOT_FOUND, + NS_ERROR_CACHE_DATA_IS_STREAM = nsresult::NS_ERROR_CACHE_DATA_IS_STREAM, + NS_ERROR_CACHE_DATA_IS_NOT_STREAM = nsresult::NS_ERROR_CACHE_DATA_IS_NOT_STREAM, + NS_ERROR_CACHE_WAIT_FOR_VALIDATION = nsresult::NS_ERROR_CACHE_WAIT_FOR_VALIDATION, + NS_ERROR_CACHE_ENTRY_DOOMED = nsresult::NS_ERROR_CACHE_ENTRY_DOOMED, + NS_ERROR_CACHE_READ_ACCESS_DENIED = nsresult::NS_ERROR_CACHE_READ_ACCESS_DENIED, + NS_ERROR_CACHE_WRITE_ACCESS_DENIED = nsresult::NS_ERROR_CACHE_WRITE_ACCESS_DENIED, + NS_ERROR_CACHE_IN_USE = nsresult::NS_ERROR_CACHE_IN_USE, + + + NS_ERROR_DOCUMENT_NOT_CACHED = nsresult::NS_ERROR_DOCUMENT_NOT_CACHED, + + + + + + NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS = nsresult::NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS, + + NS_ERROR_HOST_IS_IP_ADDRESS = nsresult::NS_ERROR_HOST_IS_IP_ADDRESS, + + + + + + + + NS_SUCCESS_ADOPTED_DATA = nsresult::NS_SUCCESS_ADOPTED_DATA, + + + NS_NET_STATUS_BEGIN_FTP_TRANSACTION = nsresult::NS_NET_STATUS_BEGIN_FTP_TRANSACTION, + NS_NET_STATUS_END_FTP_TRANSACTION = nsresult::NS_NET_STATUS_END_FTP_TRANSACTION, + + + + + NS_SUCCESS_AUTH_FINISHED = nsresult::NS_SUCCESS_AUTH_FINISHED, + + + + + NS_NET_STATUS_READING = nsresult::NS_NET_STATUS_READING, + NS_NET_STATUS_WRITING = nsresult::NS_NET_STATUS_WRITING, + + + NS_NET_STATUS_RESOLVING_HOST = nsresult::NS_NET_STATUS_RESOLVING_HOST, + NS_NET_STATUS_RESOLVED_HOST = nsresult::NS_NET_STATUS_RESOLVED_HOST, + NS_NET_STATUS_CONNECTING_TO = nsresult::NS_NET_STATUS_CONNECTING_TO, + NS_NET_STATUS_CONNECTED_TO = nsresult::NS_NET_STATUS_CONNECTED_TO, + NS_NET_STATUS_TLS_HANDSHAKE_STARTING = nsresult::NS_NET_STATUS_TLS_HANDSHAKE_STARTING, + NS_NET_STATUS_TLS_HANDSHAKE_ENDED = nsresult::NS_NET_STATUS_TLS_HANDSHAKE_ENDED, + NS_NET_STATUS_SENDING_TO = nsresult::NS_NET_STATUS_SENDING_TO, + NS_NET_STATUS_WAITING_FOR = nsresult::NS_NET_STATUS_WAITING_FOR, + NS_NET_STATUS_RECEIVING_FROM = nsresult::NS_NET_STATUS_RECEIVING_FROM, + + + + NS_ERROR_INTERCEPTION_FAILED = nsresult::NS_ERROR_INTERCEPTION_FAILED, + + + + NS_ERROR_HSTS_PRIMING_TIMEOUT = nsresult::NS_ERROR_HSTS_PRIMING_TIMEOUT, + + + + + + + + NS_ERROR_PLUGINS_PLUGINSNOTCHANGED = nsresult::NS_ERROR_PLUGINS_PLUGINSNOTCHANGED, + NS_ERROR_PLUGIN_DISABLED = nsresult::NS_ERROR_PLUGIN_DISABLED, + NS_ERROR_PLUGIN_BLOCKLISTED = nsresult::NS_ERROR_PLUGIN_BLOCKLISTED, + NS_ERROR_PLUGIN_TIME_RANGE_NOT_SUPPORTED = nsresult::NS_ERROR_PLUGIN_TIME_RANGE_NOT_SUPPORTED, + NS_ERROR_PLUGIN_CLICKTOPLAY = nsresult::NS_ERROR_PLUGIN_CLICKTOPLAY, + NS_PLUGIN_INIT_PENDING = nsresult::NS_PLUGIN_INIT_PENDING, +# 371 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_TABLELAYOUT_CELL_NOT_FOUND = nsresult::NS_TABLELAYOUT_CELL_NOT_FOUND, + + NS_POSITION_BEFORE_TABLE = nsresult::NS_POSITION_BEFORE_TABLE, + + + NS_STATE_PROPERTY_EXISTS = nsresult::NS_STATE_PROPERTY_EXISTS, + + NS_STATE_PROPERTY_NOT_THERE = nsresult::NS_STATE_PROPERTY_NOT_THERE, + + + + + + + + NS_ERROR_HTMLPARSER_CONTINUE = nsresult::NS_ERROR_HTMLPARSER_CONTINUE, + + NS_ERROR_HTMLPARSER_EOF = nsresult::NS_ERROR_HTMLPARSER_EOF, + NS_ERROR_HTMLPARSER_UNKNOWN = nsresult::NS_ERROR_HTMLPARSER_UNKNOWN, + NS_ERROR_HTMLPARSER_CANTPROPAGATE = nsresult::NS_ERROR_HTMLPARSER_CANTPROPAGATE, + NS_ERROR_HTMLPARSER_CONTEXTMISMATCH = nsresult::NS_ERROR_HTMLPARSER_CONTEXTMISMATCH, + NS_ERROR_HTMLPARSER_BADFILENAME = nsresult::NS_ERROR_HTMLPARSER_BADFILENAME, + NS_ERROR_HTMLPARSER_BADURL = nsresult::NS_ERROR_HTMLPARSER_BADURL, + NS_ERROR_HTMLPARSER_INVALIDPARSERCONTEXT = nsresult::NS_ERROR_HTMLPARSER_INVALIDPARSERCONTEXT, + NS_ERROR_HTMLPARSER_INTERRUPTED = nsresult::NS_ERROR_HTMLPARSER_INTERRUPTED, + NS_ERROR_HTMLPARSER_BLOCK = nsresult::NS_ERROR_HTMLPARSER_BLOCK, + NS_ERROR_HTMLPARSER_BADTOKENIZER = nsresult::NS_ERROR_HTMLPARSER_BADTOKENIZER, + NS_ERROR_HTMLPARSER_BADATTRIBUTE = nsresult::NS_ERROR_HTMLPARSER_BADATTRIBUTE, + NS_ERROR_HTMLPARSER_UNRESOLVEDDTD = nsresult::NS_ERROR_HTMLPARSER_UNRESOLVEDDTD, + NS_ERROR_HTMLPARSER_MISPLACEDTABLECONTENT = nsresult::NS_ERROR_HTMLPARSER_MISPLACEDTABLECONTENT, + NS_ERROR_HTMLPARSER_BADDTD = nsresult::NS_ERROR_HTMLPARSER_BADDTD, + NS_ERROR_HTMLPARSER_BADCONTEXT = nsresult::NS_ERROR_HTMLPARSER_BADCONTEXT, + NS_ERROR_HTMLPARSER_STOPPARSING = nsresult::NS_ERROR_HTMLPARSER_STOPPARSING, + NS_ERROR_HTMLPARSER_UNTERMINATEDSTRINGLITERAL = nsresult::NS_ERROR_HTMLPARSER_UNTERMINATEDSTRINGLITERAL, + NS_ERROR_HTMLPARSER_HIERARCHYTOODEEP = nsresult::NS_ERROR_HTMLPARSER_HIERARCHYTOODEEP, + NS_ERROR_HTMLPARSER_FAKE_ENDTAG = nsresult::NS_ERROR_HTMLPARSER_FAKE_ENDTAG, + NS_ERROR_HTMLPARSER_INVALID_COMMENT = nsresult::NS_ERROR_HTMLPARSER_INVALID_COMMENT, + + NS_HTMLTOKENS_NOT_AN_ENTITY = nsresult::NS_HTMLTOKENS_NOT_AN_ENTITY, + NS_HTMLPARSER_VALID_META_CHARSET = nsresult::NS_HTMLPARSER_VALID_META_CHARSET, +# 420 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_RDF_ASSERTION_ACCEPTED = nsresult::NS_RDF_ASSERTION_ACCEPTED, + + + NS_RDF_CURSOR_EMPTY = nsresult::NS_RDF_CURSOR_EMPTY, + + + NS_RDF_NO_VALUE = nsresult::NS_RDF_NO_VALUE, + + + + NS_RDF_ASSERTION_REJECTED = nsresult::NS_RDF_ASSERTION_REJECTED, + + NS_RDF_STOP_VISIT = nsresult::NS_RDF_STOP_VISIT, + + + + + + + + NS_ERROR_UCONV_NOCONV = nsresult::NS_ERROR_UCONV_NOCONV, + NS_ERROR_UDEC_ILLEGALINPUT = nsresult::NS_ERROR_UDEC_ILLEGALINPUT, + + NS_SUCCESS_USING_FALLBACK_LOCALE = nsresult::NS_SUCCESS_USING_FALLBACK_LOCALE, + NS_OK_UDEC_EXACTLENGTH = nsresult::NS_OK_UDEC_EXACTLENGTH, + NS_OK_UDEC_MOREINPUT = nsresult::NS_OK_UDEC_MOREINPUT, + NS_OK_UDEC_MOREOUTPUT = nsresult::NS_OK_UDEC_MOREOUTPUT, + NS_OK_UDEC_NOBOMFOUND = nsresult::NS_OK_UDEC_NOBOMFOUND, + NS_OK_UENC_EXACTLENGTH = nsresult::NS_OK_UENC_EXACTLENGTH, + NS_OK_UENC_MOREOUTPUT = nsresult::NS_OK_UENC_MOREOUTPUT, + NS_ERROR_UENC_NOMAPPING = nsresult::NS_ERROR_UENC_NOMAPPING, + NS_OK_UENC_MOREINPUT = nsresult::NS_OK_UENC_MOREINPUT, + + + NS_EXACT_LENGTH = nsresult::NS_EXACT_LENGTH, + NS_PARTIAL_MORE_INPUT = nsresult::NS_PARTIAL_MORE_INPUT, + NS_PARTIAL_MORE_OUTPUT = nsresult::NS_PARTIAL_MORE_OUTPUT, + NS_ERROR_ILLEGAL_INPUT = nsresult::NS_ERROR_ILLEGAL_INPUT, +# 466 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_FILE_UNRECOGNIZED_PATH = nsresult::NS_ERROR_FILE_UNRECOGNIZED_PATH, + NS_ERROR_FILE_UNRESOLVABLE_SYMLINK = nsresult::NS_ERROR_FILE_UNRESOLVABLE_SYMLINK, + NS_ERROR_FILE_EXECUTION_FAILED = nsresult::NS_ERROR_FILE_EXECUTION_FAILED, + NS_ERROR_FILE_UNKNOWN_TYPE = nsresult::NS_ERROR_FILE_UNKNOWN_TYPE, + NS_ERROR_FILE_DESTINATION_NOT_DIR = nsresult::NS_ERROR_FILE_DESTINATION_NOT_DIR, + NS_ERROR_FILE_TARGET_DOES_NOT_EXIST = nsresult::NS_ERROR_FILE_TARGET_DOES_NOT_EXIST, + NS_ERROR_FILE_COPY_OR_MOVE_FAILED = nsresult::NS_ERROR_FILE_COPY_OR_MOVE_FAILED, + NS_ERROR_FILE_ALREADY_EXISTS = nsresult::NS_ERROR_FILE_ALREADY_EXISTS, + NS_ERROR_FILE_INVALID_PATH = nsresult::NS_ERROR_FILE_INVALID_PATH, + NS_ERROR_FILE_DISK_FULL = nsresult::NS_ERROR_FILE_DISK_FULL, + NS_ERROR_FILE_CORRUPTED = nsresult::NS_ERROR_FILE_CORRUPTED, + NS_ERROR_FILE_NOT_DIRECTORY = nsresult::NS_ERROR_FILE_NOT_DIRECTORY, + NS_ERROR_FILE_IS_DIRECTORY = nsresult::NS_ERROR_FILE_IS_DIRECTORY, + NS_ERROR_FILE_IS_LOCKED = nsresult::NS_ERROR_FILE_IS_LOCKED, + NS_ERROR_FILE_TOO_BIG = nsresult::NS_ERROR_FILE_TOO_BIG, + NS_ERROR_FILE_NO_DEVICE_SPACE = nsresult::NS_ERROR_FILE_NO_DEVICE_SPACE, + NS_ERROR_FILE_NAME_TOO_LONG = nsresult::NS_ERROR_FILE_NAME_TOO_LONG, + NS_ERROR_FILE_NOT_FOUND = nsresult::NS_ERROR_FILE_NOT_FOUND, + NS_ERROR_FILE_READ_ONLY = nsresult::NS_ERROR_FILE_READ_ONLY, + NS_ERROR_FILE_DIR_NOT_EMPTY = nsresult::NS_ERROR_FILE_DIR_NOT_EMPTY, + NS_ERROR_FILE_ACCESS_DENIED = nsresult::NS_ERROR_FILE_ACCESS_DENIED, + + NS_SUCCESS_FILE_DIRECTORY_EMPTY = nsresult::NS_SUCCESS_FILE_DIRECTORY_EMPTY, + + NS_SUCCESS_AGGREGATE_RESULT = nsresult::NS_SUCCESS_AGGREGATE_RESULT, +# 502 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_DOM_INDEX_SIZE_ERR = nsresult::NS_ERROR_DOM_INDEX_SIZE_ERR, + NS_ERROR_DOM_HIERARCHY_REQUEST_ERR = nsresult::NS_ERROR_DOM_HIERARCHY_REQUEST_ERR, + NS_ERROR_DOM_WRONG_DOCUMENT_ERR = nsresult::NS_ERROR_DOM_WRONG_DOCUMENT_ERR, + NS_ERROR_DOM_INVALID_CHARACTER_ERR = nsresult::NS_ERROR_DOM_INVALID_CHARACTER_ERR, + NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR = nsresult::NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR, + NS_ERROR_DOM_NOT_FOUND_ERR = nsresult::NS_ERROR_DOM_NOT_FOUND_ERR, + NS_ERROR_DOM_NOT_SUPPORTED_ERR = nsresult::NS_ERROR_DOM_NOT_SUPPORTED_ERR, + NS_ERROR_DOM_INUSE_ATTRIBUTE_ERR = nsresult::NS_ERROR_DOM_INUSE_ATTRIBUTE_ERR, + NS_ERROR_DOM_INVALID_STATE_ERR = nsresult::NS_ERROR_DOM_INVALID_STATE_ERR, + NS_ERROR_DOM_SYNTAX_ERR = nsresult::NS_ERROR_DOM_SYNTAX_ERR, + NS_ERROR_DOM_INVALID_MODIFICATION_ERR = nsresult::NS_ERROR_DOM_INVALID_MODIFICATION_ERR, + NS_ERROR_DOM_NAMESPACE_ERR = nsresult::NS_ERROR_DOM_NAMESPACE_ERR, + NS_ERROR_DOM_INVALID_ACCESS_ERR = nsresult::NS_ERROR_DOM_INVALID_ACCESS_ERR, + NS_ERROR_DOM_TYPE_MISMATCH_ERR = nsresult::NS_ERROR_DOM_TYPE_MISMATCH_ERR, + NS_ERROR_DOM_SECURITY_ERR = nsresult::NS_ERROR_DOM_SECURITY_ERR, + NS_ERROR_DOM_NETWORK_ERR = nsresult::NS_ERROR_DOM_NETWORK_ERR, + NS_ERROR_DOM_ABORT_ERR = nsresult::NS_ERROR_DOM_ABORT_ERR, + NS_ERROR_DOM_URL_MISMATCH_ERR = nsresult::NS_ERROR_DOM_URL_MISMATCH_ERR, + NS_ERROR_DOM_QUOTA_EXCEEDED_ERR = nsresult::NS_ERROR_DOM_QUOTA_EXCEEDED_ERR, + NS_ERROR_DOM_TIMEOUT_ERR = nsresult::NS_ERROR_DOM_TIMEOUT_ERR, + NS_ERROR_DOM_INVALID_NODE_TYPE_ERR = nsresult::NS_ERROR_DOM_INVALID_NODE_TYPE_ERR, + NS_ERROR_DOM_DATA_CLONE_ERR = nsresult::NS_ERROR_DOM_DATA_CLONE_ERR, + + NS_ERROR_TYPE_ERR = nsresult::NS_ERROR_TYPE_ERR, + NS_ERROR_RANGE_ERR = nsresult::NS_ERROR_RANGE_ERR, + + NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR = nsresult::NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR, + NS_ERROR_DOM_INVALID_POINTER_ERR = nsresult::NS_ERROR_DOM_INVALID_POINTER_ERR, + + NS_ERROR_DOM_UNKNOWN_ERR = nsresult::NS_ERROR_DOM_UNKNOWN_ERR, + NS_ERROR_DOM_DATA_ERR = nsresult::NS_ERROR_DOM_DATA_ERR, + NS_ERROR_DOM_OPERATION_ERR = nsresult::NS_ERROR_DOM_OPERATION_ERR, + + NS_ERROR_DOM_NOT_ALLOWED_ERR = nsresult::NS_ERROR_DOM_NOT_ALLOWED_ERR, + + NS_ERROR_DOM_SECMAN_ERR = nsresult::NS_ERROR_DOM_SECMAN_ERR, + NS_ERROR_DOM_WRONG_TYPE_ERR = nsresult::NS_ERROR_DOM_WRONG_TYPE_ERR, + NS_ERROR_DOM_NOT_OBJECT_ERR = nsresult::NS_ERROR_DOM_NOT_OBJECT_ERR, + NS_ERROR_DOM_NOT_XPC_OBJECT_ERR = nsresult::NS_ERROR_DOM_NOT_XPC_OBJECT_ERR, + NS_ERROR_DOM_NOT_NUMBER_ERR = nsresult::NS_ERROR_DOM_NOT_NUMBER_ERR, + NS_ERROR_DOM_NOT_BOOLEAN_ERR = nsresult::NS_ERROR_DOM_NOT_BOOLEAN_ERR, + NS_ERROR_DOM_NOT_FUNCTION_ERR = nsresult::NS_ERROR_DOM_NOT_FUNCTION_ERR, + NS_ERROR_DOM_TOO_FEW_PARAMETERS_ERR = nsresult::NS_ERROR_DOM_TOO_FEW_PARAMETERS_ERR, + NS_ERROR_DOM_BAD_DOCUMENT_DOMAIN = nsresult::NS_ERROR_DOM_BAD_DOCUMENT_DOMAIN, + NS_ERROR_DOM_PROP_ACCESS_DENIED = nsresult::NS_ERROR_DOM_PROP_ACCESS_DENIED, + NS_ERROR_DOM_XPCONNECT_ACCESS_DENIED = nsresult::NS_ERROR_DOM_XPCONNECT_ACCESS_DENIED, + NS_ERROR_DOM_BAD_URI = nsresult::NS_ERROR_DOM_BAD_URI, + NS_ERROR_DOM_RETVAL_UNDEFINED = nsresult::NS_ERROR_DOM_RETVAL_UNDEFINED, + NS_ERROR_DOM_QUOTA_REACHED = nsresult::NS_ERROR_DOM_QUOTA_REACHED, + + + NS_ERROR_UNCATCHABLE_EXCEPTION = nsresult::NS_ERROR_UNCATCHABLE_EXCEPTION, + + NS_ERROR_DOM_MALFORMED_URI = nsresult::NS_ERROR_DOM_MALFORMED_URI, + NS_ERROR_DOM_INVALID_HEADER_NAME = nsresult::NS_ERROR_DOM_INVALID_HEADER_NAME, + + NS_ERROR_DOM_INVALID_STATE_XHR_HAS_INVALID_CONTEXT = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_HAS_INVALID_CONTEXT, + NS_ERROR_DOM_INVALID_STATE_XHR_MUST_BE_OPENED = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_MUST_BE_OPENED, + NS_ERROR_DOM_INVALID_STATE_XHR_MUST_NOT_BE_SENDING = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_MUST_NOT_BE_SENDING, + NS_ERROR_DOM_INVALID_STATE_XHR_MUST_NOT_BE_LOADING_OR_DONE = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_MUST_NOT_BE_LOADING_OR_DONE, + NS_ERROR_DOM_INVALID_STATE_XHR_HAS_WRONG_RESPONSETYPE_FOR_RESPONSEXML = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_HAS_WRONG_RESPONSETYPE_FOR_RESPONSEXML, + NS_ERROR_DOM_INVALID_STATE_XHR_HAS_WRONG_RESPONSETYPE_FOR_RESPONSETEXT = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_HAS_WRONG_RESPONSETYPE_FOR_RESPONSETEXT, + NS_ERROR_DOM_INVALID_STATE_XHR_CHUNKED_RESPONSETYPES_UNSUPPORTED_FOR_SYNC = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_CHUNKED_RESPONSETYPES_UNSUPPORTED_FOR_SYNC, + NS_ERROR_DOM_INVALID_ACCESS_XHR_TIMEOUT_AND_RESPONSETYPE_UNSUPPORTED_FOR_SYNC = nsresult::NS_ERROR_DOM_INVALID_ACCESS_XHR_TIMEOUT_AND_RESPONSETYPE_UNSUPPORTED_FOR_SYNC, + + + + + + NS_SUCCESS_DOM_NO_OPERATION = nsresult::NS_SUCCESS_DOM_NO_OPERATION, + + + + + + + NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW = nsresult::NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW, + + + + + + + NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW_UNCATCHABLE = nsresult::NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW_UNCATCHABLE, + + + + + + + + NS_IMAGELIB_SUCCESS_LOAD_FINISHED = nsresult::NS_IMAGELIB_SUCCESS_LOAD_FINISHED, + NS_IMAGELIB_CHANGING_OWNER = nsresult::NS_IMAGELIB_CHANGING_OWNER, + + NS_IMAGELIB_ERROR_FAILURE = nsresult::NS_IMAGELIB_ERROR_FAILURE, + NS_IMAGELIB_ERROR_NO_DECODER = nsresult::NS_IMAGELIB_ERROR_NO_DECODER, + NS_IMAGELIB_ERROR_NOT_FINISHED = nsresult::NS_IMAGELIB_ERROR_NOT_FINISHED, + NS_IMAGELIB_ERROR_NO_ENCODER = nsresult::NS_IMAGELIB_ERROR_NO_ENCODER, + + + + + + + + NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND = nsresult::NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND, + NS_SUCCESS_EDITOR_FOUND_TARGET = nsresult::NS_SUCCESS_EDITOR_FOUND_TARGET, + + + + + + + + NS_ERROR_XPC_NOT_ENOUGH_ARGS = nsresult::NS_ERROR_XPC_NOT_ENOUGH_ARGS, + NS_ERROR_XPC_NEED_OUT_OBJECT = nsresult::NS_ERROR_XPC_NEED_OUT_OBJECT, + NS_ERROR_XPC_CANT_SET_OUT_VAL = nsresult::NS_ERROR_XPC_CANT_SET_OUT_VAL, + NS_ERROR_XPC_NATIVE_RETURNED_FAILURE = nsresult::NS_ERROR_XPC_NATIVE_RETURNED_FAILURE, + NS_ERROR_XPC_CANT_GET_INTERFACE_INFO = nsresult::NS_ERROR_XPC_CANT_GET_INTERFACE_INFO, + NS_ERROR_XPC_CANT_GET_PARAM_IFACE_INFO = nsresult::NS_ERROR_XPC_CANT_GET_PARAM_IFACE_INFO, + NS_ERROR_XPC_CANT_GET_METHOD_INFO = nsresult::NS_ERROR_XPC_CANT_GET_METHOD_INFO, + NS_ERROR_XPC_UNEXPECTED = nsresult::NS_ERROR_XPC_UNEXPECTED, + NS_ERROR_XPC_BAD_CONVERT_JS = nsresult::NS_ERROR_XPC_BAD_CONVERT_JS, + NS_ERROR_XPC_BAD_CONVERT_NATIVE = nsresult::NS_ERROR_XPC_BAD_CONVERT_NATIVE, + NS_ERROR_XPC_BAD_CONVERT_JS_NULL_REF = nsresult::NS_ERROR_XPC_BAD_CONVERT_JS_NULL_REF, + NS_ERROR_XPC_BAD_OP_ON_WN_PROTO = nsresult::NS_ERROR_XPC_BAD_OP_ON_WN_PROTO, + NS_ERROR_XPC_CANT_CONVERT_WN_TO_FUN = nsresult::NS_ERROR_XPC_CANT_CONVERT_WN_TO_FUN, + NS_ERROR_XPC_CANT_DEFINE_PROP_ON_WN = nsresult::NS_ERROR_XPC_CANT_DEFINE_PROP_ON_WN, + NS_ERROR_XPC_CANT_WATCH_WN_STATIC = nsresult::NS_ERROR_XPC_CANT_WATCH_WN_STATIC, + NS_ERROR_XPC_CANT_EXPORT_WN_STATIC = nsresult::NS_ERROR_XPC_CANT_EXPORT_WN_STATIC, + NS_ERROR_XPC_SCRIPTABLE_CALL_FAILED = nsresult::NS_ERROR_XPC_SCRIPTABLE_CALL_FAILED, + NS_ERROR_XPC_SCRIPTABLE_CTOR_FAILED = nsresult::NS_ERROR_XPC_SCRIPTABLE_CTOR_FAILED, + NS_ERROR_XPC_CANT_CALL_WO_SCRIPTABLE = nsresult::NS_ERROR_XPC_CANT_CALL_WO_SCRIPTABLE, + NS_ERROR_XPC_CANT_CTOR_WO_SCRIPTABLE = nsresult::NS_ERROR_XPC_CANT_CTOR_WO_SCRIPTABLE, + NS_ERROR_XPC_CI_RETURNED_FAILURE = nsresult::NS_ERROR_XPC_CI_RETURNED_FAILURE, + NS_ERROR_XPC_GS_RETURNED_FAILURE = nsresult::NS_ERROR_XPC_GS_RETURNED_FAILURE, + NS_ERROR_XPC_BAD_CID = nsresult::NS_ERROR_XPC_BAD_CID, + NS_ERROR_XPC_BAD_IID = nsresult::NS_ERROR_XPC_BAD_IID, + NS_ERROR_XPC_CANT_CREATE_WN = nsresult::NS_ERROR_XPC_CANT_CREATE_WN, + NS_ERROR_XPC_JS_THREW_EXCEPTION = nsresult::NS_ERROR_XPC_JS_THREW_EXCEPTION, + NS_ERROR_XPC_JS_THREW_NATIVE_OBJECT = nsresult::NS_ERROR_XPC_JS_THREW_NATIVE_OBJECT, + NS_ERROR_XPC_JS_THREW_JS_OBJECT = nsresult::NS_ERROR_XPC_JS_THREW_JS_OBJECT, + NS_ERROR_XPC_JS_THREW_NULL = nsresult::NS_ERROR_XPC_JS_THREW_NULL, + NS_ERROR_XPC_JS_THREW_STRING = nsresult::NS_ERROR_XPC_JS_THREW_STRING, + NS_ERROR_XPC_JS_THREW_NUMBER = nsresult::NS_ERROR_XPC_JS_THREW_NUMBER, + NS_ERROR_XPC_JAVASCRIPT_ERROR = nsresult::NS_ERROR_XPC_JAVASCRIPT_ERROR, + NS_ERROR_XPC_JAVASCRIPT_ERROR_WITH_DETAILS = nsresult::NS_ERROR_XPC_JAVASCRIPT_ERROR_WITH_DETAILS, + NS_ERROR_XPC_CANT_CONVERT_PRIMITIVE_TO_ARRAY = nsresult::NS_ERROR_XPC_CANT_CONVERT_PRIMITIVE_TO_ARRAY, + NS_ERROR_XPC_CANT_CONVERT_OBJECT_TO_ARRAY = nsresult::NS_ERROR_XPC_CANT_CONVERT_OBJECT_TO_ARRAY, + NS_ERROR_XPC_NOT_ENOUGH_ELEMENTS_IN_ARRAY = nsresult::NS_ERROR_XPC_NOT_ENOUGH_ELEMENTS_IN_ARRAY, + NS_ERROR_XPC_CANT_GET_ARRAY_INFO = nsresult::NS_ERROR_XPC_CANT_GET_ARRAY_INFO, + NS_ERROR_XPC_NOT_ENOUGH_CHARS_IN_STRING = nsresult::NS_ERROR_XPC_NOT_ENOUGH_CHARS_IN_STRING, + NS_ERROR_XPC_SECURITY_MANAGER_VETO = nsresult::NS_ERROR_XPC_SECURITY_MANAGER_VETO, + NS_ERROR_XPC_INTERFACE_NOT_SCRIPTABLE = nsresult::NS_ERROR_XPC_INTERFACE_NOT_SCRIPTABLE, + NS_ERROR_XPC_INTERFACE_NOT_FROM_NSISUPPORTS = nsresult::NS_ERROR_XPC_INTERFACE_NOT_FROM_NSISUPPORTS, + NS_ERROR_XPC_CANT_GET_JSOBJECT_OF_DOM_OBJECT = nsresult::NS_ERROR_XPC_CANT_GET_JSOBJECT_OF_DOM_OBJECT, + NS_ERROR_XPC_CANT_SET_READ_ONLY_CONSTANT = nsresult::NS_ERROR_XPC_CANT_SET_READ_ONLY_CONSTANT, + NS_ERROR_XPC_CANT_SET_READ_ONLY_ATTRIBUTE = nsresult::NS_ERROR_XPC_CANT_SET_READ_ONLY_ATTRIBUTE, + NS_ERROR_XPC_CANT_SET_READ_ONLY_METHOD = nsresult::NS_ERROR_XPC_CANT_SET_READ_ONLY_METHOD, + NS_ERROR_XPC_CANT_ADD_PROP_TO_WRAPPED_NATIVE = nsresult::NS_ERROR_XPC_CANT_ADD_PROP_TO_WRAPPED_NATIVE, + NS_ERROR_XPC_CALL_TO_SCRIPTABLE_FAILED = nsresult::NS_ERROR_XPC_CALL_TO_SCRIPTABLE_FAILED, + NS_ERROR_XPC_JSOBJECT_HAS_NO_FUNCTION_NAMED = nsresult::NS_ERROR_XPC_JSOBJECT_HAS_NO_FUNCTION_NAMED, + NS_ERROR_XPC_BAD_ID_STRING = nsresult::NS_ERROR_XPC_BAD_ID_STRING, + NS_ERROR_XPC_BAD_INITIALIZER_NAME = nsresult::NS_ERROR_XPC_BAD_INITIALIZER_NAME, + NS_ERROR_XPC_HAS_BEEN_SHUTDOWN = nsresult::NS_ERROR_XPC_HAS_BEEN_SHUTDOWN, + NS_ERROR_XPC_CANT_MODIFY_PROP_ON_WN = nsresult::NS_ERROR_XPC_CANT_MODIFY_PROP_ON_WN, + NS_ERROR_XPC_BAD_CONVERT_JS_ZERO_ISNOT_NULL = nsresult::NS_ERROR_XPC_BAD_CONVERT_JS_ZERO_ISNOT_NULL, + NS_ERROR_XPC_CANT_PASS_CPOW_TO_NATIVE = nsresult::NS_ERROR_XPC_CANT_PASS_CPOW_TO_NATIVE, +# 678 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_LAUNCHED_CHILD_PROCESS = nsresult::NS_ERROR_LAUNCHED_CHILD_PROCESS, +# 687 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_CSP_FORM_ACTION_VIOLATION = nsresult::NS_ERROR_CSP_FORM_ACTION_VIOLATION, + NS_ERROR_CSP_FRAME_ANCESTOR_VIOLATION = nsresult::NS_ERROR_CSP_FRAME_ANCESTOR_VIOLATION, + + + NS_ERROR_SRI_CORRUPT = nsresult::NS_ERROR_SRI_CORRUPT, + NS_ERROR_SRI_DISABLED = nsresult::NS_ERROR_SRI_DISABLED, + NS_ERROR_SRI_NOT_ELIGIBLE = nsresult::NS_ERROR_SRI_NOT_ELIGIBLE, + NS_ERROR_SRI_UNEXPECTED_HASH_TYPE = nsresult::NS_ERROR_SRI_UNEXPECTED_HASH_TYPE, + NS_ERROR_SRI_IMPORT = nsresult::NS_ERROR_SRI_IMPORT, + + + + NS_ERROR_CMS_VERIFY_NOT_SIGNED = nsresult::NS_ERROR_CMS_VERIFY_NOT_SIGNED, + NS_ERROR_CMS_VERIFY_NO_CONTENT_INFO = nsresult::NS_ERROR_CMS_VERIFY_NO_CONTENT_INFO, + NS_ERROR_CMS_VERIFY_BAD_DIGEST = nsresult::NS_ERROR_CMS_VERIFY_BAD_DIGEST, + NS_ERROR_CMS_VERIFY_NOCERT = nsresult::NS_ERROR_CMS_VERIFY_NOCERT, + NS_ERROR_CMS_VERIFY_UNTRUSTED = nsresult::NS_ERROR_CMS_VERIFY_UNTRUSTED, + NS_ERROR_CMS_VERIFY_ERROR_UNVERIFIED = nsresult::NS_ERROR_CMS_VERIFY_ERROR_UNVERIFIED, + NS_ERROR_CMS_VERIFY_ERROR_PROCESSING = nsresult::NS_ERROR_CMS_VERIFY_ERROR_PROCESSING, + NS_ERROR_CMS_VERIFY_BAD_SIGNATURE = nsresult::NS_ERROR_CMS_VERIFY_BAD_SIGNATURE, + NS_ERROR_CMS_VERIFY_DIGEST_MISMATCH = nsresult::NS_ERROR_CMS_VERIFY_DIGEST_MISMATCH, + NS_ERROR_CMS_VERIFY_UNKNOWN_ALGO = nsresult::NS_ERROR_CMS_VERIFY_UNKNOWN_ALGO, + NS_ERROR_CMS_VERIFY_UNSUPPORTED_ALGO = nsresult::NS_ERROR_CMS_VERIFY_UNSUPPORTED_ALGO, + NS_ERROR_CMS_VERIFY_MALFORMED_SIGNATURE = nsresult::NS_ERROR_CMS_VERIFY_MALFORMED_SIGNATURE, + NS_ERROR_CMS_VERIFY_HEADER_MISMATCH = nsresult::NS_ERROR_CMS_VERIFY_HEADER_MISMATCH, + NS_ERROR_CMS_VERIFY_NOT_YET_ATTEMPTED = nsresult::NS_ERROR_CMS_VERIFY_NOT_YET_ATTEMPTED, + NS_ERROR_CMS_VERIFY_CERT_WITHOUT_ADDRESS = nsresult::NS_ERROR_CMS_VERIFY_CERT_WITHOUT_ADDRESS, + NS_ERROR_CMS_ENCRYPT_NO_BULK_ALG = nsresult::NS_ERROR_CMS_ENCRYPT_NO_BULK_ALG, + NS_ERROR_CMS_ENCRYPT_INCOMPLETE = nsresult::NS_ERROR_CMS_ENCRYPT_INCOMPLETE, +# 724 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_DOM_INVALID_EXPRESSION_ERR = nsresult::NS_ERROR_DOM_INVALID_EXPRESSION_ERR, + NS_ERROR_DOM_TYPE_ERR = nsresult::NS_ERROR_DOM_TYPE_ERR, + + + + + + + + NS_ERROR_WONT_HANDLE_CONTENT = nsresult::NS_ERROR_WONT_HANDLE_CONTENT, + + + NS_ERROR_MALWARE_URI = nsresult::NS_ERROR_MALWARE_URI, + NS_ERROR_PHISHING_URI = nsresult::NS_ERROR_PHISHING_URI, + NS_ERROR_TRACKING_URI = nsresult::NS_ERROR_TRACKING_URI, + NS_ERROR_UNWANTED_URI = nsresult::NS_ERROR_UNWANTED_URI, + NS_ERROR_BLOCKED_URI = nsresult::NS_ERROR_BLOCKED_URI, + + + NS_ERROR_SAVE_LINK_AS_TIMEOUT = nsresult::NS_ERROR_SAVE_LINK_AS_TIMEOUT, + + + NS_ERROR_PARSED_DATA_CACHED = nsresult::NS_ERROR_PARSED_DATA_CACHED, + + + + NS_REFRESHURI_HEADER_FOUND = nsresult::NS_REFRESHURI_HEADER_FOUND, +# 759 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_IMAGE_SRC_CHANGED = nsresult::NS_ERROR_IMAGE_SRC_CHANGED, + NS_ERROR_IMAGE_BLOCKED = nsresult::NS_ERROR_IMAGE_BLOCKED, + + NS_ERROR_CONTENT_BLOCKED = nsresult::NS_ERROR_CONTENT_BLOCKED, + NS_ERROR_CONTENT_BLOCKED_SHOW_ALT = nsresult::NS_ERROR_CONTENT_BLOCKED_SHOW_ALT, + + NS_PROPTABLE_PROP_NOT_THERE = nsresult::NS_PROPTABLE_PROP_NOT_THERE, + + NS_ERROR_XBL_BLOCKED = nsresult::NS_ERROR_XBL_BLOCKED, + + NS_ERROR_CONTENT_CRASHED = nsresult::NS_ERROR_CONTENT_CRASHED, + + + NS_HTML_STYLE_PROPERTY_NOT_THERE = nsresult::NS_HTML_STYLE_PROPERTY_NOT_THERE, + NS_CONTENT_BLOCKED = nsresult::NS_CONTENT_BLOCKED, + NS_CONTENT_BLOCKED_SHOW_ALT = nsresult::NS_CONTENT_BLOCKED_SHOW_ALT, + NS_PROPTABLE_PROP_OVERWRITTEN = nsresult::NS_PROPTABLE_PROP_OVERWRITTEN, + + NS_FINDBROADCASTER_NOT_FOUND = nsresult::NS_FINDBROADCASTER_NOT_FOUND, + NS_FINDBROADCASTER_FOUND = nsresult::NS_FINDBROADCASTER_FOUND, + NS_FINDBROADCASTER_AWAIT_OVERLAYS = nsresult::NS_FINDBROADCASTER_AWAIT_OVERLAYS, + + + + + + + + NS_ERROR_XPATH_INVALID_ARG = nsresult::NS_ERROR_XPATH_INVALID_ARG, + + NS_ERROR_XSLT_PARSE_FAILURE = nsresult::NS_ERROR_XSLT_PARSE_FAILURE, + NS_ERROR_XPATH_PARSE_FAILURE = nsresult::NS_ERROR_XPATH_PARSE_FAILURE, + NS_ERROR_XSLT_ALREADY_SET = nsresult::NS_ERROR_XSLT_ALREADY_SET, + NS_ERROR_XSLT_EXECUTION_FAILURE = nsresult::NS_ERROR_XSLT_EXECUTION_FAILURE, + NS_ERROR_XPATH_UNKNOWN_FUNCTION = nsresult::NS_ERROR_XPATH_UNKNOWN_FUNCTION, + NS_ERROR_XSLT_BAD_RECURSION = nsresult::NS_ERROR_XSLT_BAD_RECURSION, + NS_ERROR_XSLT_BAD_VALUE = nsresult::NS_ERROR_XSLT_BAD_VALUE, + NS_ERROR_XSLT_NODESET_EXPECTED = nsresult::NS_ERROR_XSLT_NODESET_EXPECTED, + NS_ERROR_XSLT_ABORTED = nsresult::NS_ERROR_XSLT_ABORTED, + NS_ERROR_XSLT_NETWORK_ERROR = nsresult::NS_ERROR_XSLT_NETWORK_ERROR, + NS_ERROR_XSLT_WRONG_MIME_TYPE = nsresult::NS_ERROR_XSLT_WRONG_MIME_TYPE, + NS_ERROR_XSLT_LOAD_RECURSION = nsresult::NS_ERROR_XSLT_LOAD_RECURSION, + NS_ERROR_XPATH_BAD_ARGUMENT_COUNT = nsresult::NS_ERROR_XPATH_BAD_ARGUMENT_COUNT, + NS_ERROR_XPATH_BAD_EXTENSION_FUNCTION = nsresult::NS_ERROR_XPATH_BAD_EXTENSION_FUNCTION, + NS_ERROR_XPATH_PAREN_EXPECTED = nsresult::NS_ERROR_XPATH_PAREN_EXPECTED, + NS_ERROR_XPATH_INVALID_AXIS = nsresult::NS_ERROR_XPATH_INVALID_AXIS, + NS_ERROR_XPATH_NO_NODE_TYPE_TEST = nsresult::NS_ERROR_XPATH_NO_NODE_TYPE_TEST, + NS_ERROR_XPATH_BRACKET_EXPECTED = nsresult::NS_ERROR_XPATH_BRACKET_EXPECTED, + NS_ERROR_XPATH_INVALID_VAR_NAME = nsresult::NS_ERROR_XPATH_INVALID_VAR_NAME, + NS_ERROR_XPATH_UNEXPECTED_END = nsresult::NS_ERROR_XPATH_UNEXPECTED_END, + NS_ERROR_XPATH_OPERATOR_EXPECTED = nsresult::NS_ERROR_XPATH_OPERATOR_EXPECTED, + NS_ERROR_XPATH_UNCLOSED_LITERAL = nsresult::NS_ERROR_XPATH_UNCLOSED_LITERAL, + NS_ERROR_XPATH_BAD_COLON = nsresult::NS_ERROR_XPATH_BAD_COLON, + NS_ERROR_XPATH_BAD_BANG = nsresult::NS_ERROR_XPATH_BAD_BANG, + NS_ERROR_XPATH_ILLEGAL_CHAR = nsresult::NS_ERROR_XPATH_ILLEGAL_CHAR, + NS_ERROR_XPATH_BINARY_EXPECTED = nsresult::NS_ERROR_XPATH_BINARY_EXPECTED, + NS_ERROR_XSLT_LOAD_BLOCKED_ERROR = nsresult::NS_ERROR_XSLT_LOAD_BLOCKED_ERROR, + NS_ERROR_XPATH_INVALID_EXPRESSION_EVALUATED = nsresult::NS_ERROR_XPATH_INVALID_EXPRESSION_EVALUATED, + NS_ERROR_XPATH_UNBALANCED_CURLY_BRACE = nsresult::NS_ERROR_XPATH_UNBALANCED_CURLY_BRACE, + NS_ERROR_XSLT_BAD_NODE_NAME = nsresult::NS_ERROR_XSLT_BAD_NODE_NAME, + NS_ERROR_XSLT_VAR_ALREADY_SET = nsresult::NS_ERROR_XSLT_VAR_ALREADY_SET, + NS_ERROR_XSLT_CALL_TO_KEY_NOT_ALLOWED = nsresult::NS_ERROR_XSLT_CALL_TO_KEY_NOT_ALLOWED, + + NS_XSLT_GET_NEW_HANDLER = nsresult::NS_XSLT_GET_NEW_HANDLER, +# 831 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_TRANSPORT_INIT = nsresult::NS_ERROR_TRANSPORT_INIT, + + NS_ERROR_DUPLICATE_HANDLE = nsresult::NS_ERROR_DUPLICATE_HANDLE, + + NS_ERROR_BRIDGE_OPEN_PARENT = nsresult::NS_ERROR_BRIDGE_OPEN_PARENT, + + NS_ERROR_BRIDGE_OPEN_CHILD = nsresult::NS_ERROR_BRIDGE_OPEN_CHILD, + + + + + + + + NS_ERROR_DOM_SVG_WRONG_TYPE_ERR = nsresult::NS_ERROR_DOM_SVG_WRONG_TYPE_ERR, + + NS_ERROR_DOM_SVG_MATRIX_NOT_INVERTABLE = nsresult::NS_ERROR_DOM_SVG_MATRIX_NOT_INVERTABLE, +# 863 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_STORAGE_BUSY = nsresult::NS_ERROR_STORAGE_BUSY, + NS_ERROR_STORAGE_IOERR = nsresult::NS_ERROR_STORAGE_IOERR, + NS_ERROR_STORAGE_CONSTRAINT = nsresult::NS_ERROR_STORAGE_CONSTRAINT, + + + + + + + + NS_ERROR_DOM_FILE_NOT_FOUND_ERR = nsresult::NS_ERROR_DOM_FILE_NOT_FOUND_ERR, + NS_ERROR_DOM_FILE_NOT_READABLE_ERR = nsresult::NS_ERROR_DOM_FILE_NOT_READABLE_ERR, + NS_ERROR_DOM_FILE_ABORT_ERR = nsresult::NS_ERROR_DOM_FILE_ABORT_ERR, +# 884 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR, + NS_ERROR_DOM_INDEXEDDB_NOT_FOUND_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_NOT_FOUND_ERR, + NS_ERROR_DOM_INDEXEDDB_CONSTRAINT_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_CONSTRAINT_ERR, + NS_ERROR_DOM_INDEXEDDB_DATA_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_DATA_ERR, + NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR, + NS_ERROR_DOM_INDEXEDDB_TRANSACTION_INACTIVE_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_TRANSACTION_INACTIVE_ERR, + NS_ERROR_DOM_INDEXEDDB_ABORT_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_ABORT_ERR, + NS_ERROR_DOM_INDEXEDDB_READ_ONLY_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_READ_ONLY_ERR, + NS_ERROR_DOM_INDEXEDDB_TIMEOUT_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_TIMEOUT_ERR, + NS_ERROR_DOM_INDEXEDDB_QUOTA_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_QUOTA_ERR, + NS_ERROR_DOM_INDEXEDDB_VERSION_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_VERSION_ERR, + NS_ERROR_DOM_INDEXEDDB_RECOVERABLE_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_RECOVERABLE_ERR, + + + + + + + + NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR = nsresult::NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR, + NS_ERROR_DOM_FILEHANDLE_NOT_ALLOWED_ERR = nsresult::NS_ERROR_DOM_FILEHANDLE_NOT_ALLOWED_ERR, + NS_ERROR_DOM_FILEHANDLE_INACTIVE_ERR = nsresult::NS_ERROR_DOM_FILEHANDLE_INACTIVE_ERR, + NS_ERROR_DOM_FILEHANDLE_ABORT_ERR = nsresult::NS_ERROR_DOM_FILEHANDLE_ABORT_ERR, + NS_ERROR_DOM_FILEHANDLE_READ_ONLY_ERR = nsresult::NS_ERROR_DOM_FILEHANDLE_READ_ONLY_ERR, + NS_ERROR_DOM_FILEHANDLE_QUOTA_ERR = nsresult::NS_ERROR_DOM_FILEHANDLE_QUOTA_ERR, + + + + + + + NS_ERROR_SIGNED_JAR_NOT_SIGNED = nsresult::NS_ERROR_SIGNED_JAR_NOT_SIGNED, + NS_ERROR_SIGNED_JAR_MODIFIED_ENTRY = nsresult::NS_ERROR_SIGNED_JAR_MODIFIED_ENTRY, + NS_ERROR_SIGNED_JAR_UNSIGNED_ENTRY = nsresult::NS_ERROR_SIGNED_JAR_UNSIGNED_ENTRY, + NS_ERROR_SIGNED_JAR_ENTRY_MISSING = nsresult::NS_ERROR_SIGNED_JAR_ENTRY_MISSING, + NS_ERROR_SIGNED_JAR_WRONG_SIGNATURE = nsresult::NS_ERROR_SIGNED_JAR_WRONG_SIGNATURE, + NS_ERROR_SIGNED_JAR_ENTRY_TOO_LARGE = nsresult::NS_ERROR_SIGNED_JAR_ENTRY_TOO_LARGE, + NS_ERROR_SIGNED_JAR_ENTRY_INVALID = nsresult::NS_ERROR_SIGNED_JAR_ENTRY_INVALID, + NS_ERROR_SIGNED_JAR_MANIFEST_INVALID = nsresult::NS_ERROR_SIGNED_JAR_MANIFEST_INVALID, + + + + + + + NS_ERROR_DOM_FILESYSTEM_INVALID_PATH_ERR = nsresult::NS_ERROR_DOM_FILESYSTEM_INVALID_PATH_ERR, + NS_ERROR_DOM_FILESYSTEM_INVALID_MODIFICATION_ERR = nsresult::NS_ERROR_DOM_FILESYSTEM_INVALID_MODIFICATION_ERR, + NS_ERROR_DOM_FILESYSTEM_NO_MODIFICATION_ALLOWED_ERR = nsresult::NS_ERROR_DOM_FILESYSTEM_NO_MODIFICATION_ALLOWED_ERR, + NS_ERROR_DOM_FILESYSTEM_PATH_EXISTS_ERR = nsresult::NS_ERROR_DOM_FILESYSTEM_PATH_EXISTS_ERR, + NS_ERROR_DOM_FILESYSTEM_TYPE_MISMATCH_ERR = nsresult::NS_ERROR_DOM_FILESYSTEM_TYPE_MISMATCH_ERR, + NS_ERROR_DOM_FILESYSTEM_UNKNOWN_ERR = nsresult::NS_ERROR_DOM_FILESYSTEM_UNKNOWN_ERR, + + + + + + + NS_ERROR_SIGNED_APP_MANIFEST_INVALID = nsresult::NS_ERROR_SIGNED_APP_MANIFEST_INVALID, + + + + + + + NS_ERROR_DOM_ANIM_MISSING_PROPS_ERR = nsresult::NS_ERROR_DOM_ANIM_MISSING_PROPS_ERR, + + + + + + + NS_ERROR_DOM_PUSH_INVALID_REGISTRATION_ERR = nsresult::NS_ERROR_DOM_PUSH_INVALID_REGISTRATION_ERR, + NS_ERROR_DOM_PUSH_DENIED_ERR = nsresult::NS_ERROR_DOM_PUSH_DENIED_ERR, + NS_ERROR_DOM_PUSH_ABORT_ERR = nsresult::NS_ERROR_DOM_PUSH_ABORT_ERR, + NS_ERROR_DOM_PUSH_SERVICE_UNREACHABLE = nsresult::NS_ERROR_DOM_PUSH_SERVICE_UNREACHABLE, + NS_ERROR_DOM_PUSH_INVALID_KEY_ERR = nsresult::NS_ERROR_DOM_PUSH_INVALID_KEY_ERR, + NS_ERROR_DOM_PUSH_MISMATCHED_KEY_ERR = nsresult::NS_ERROR_DOM_PUSH_MISMATCHED_KEY_ERR, + + + + + + + + NS_ERROR_DOM_MEDIA_ABORT_ERR = nsresult::NS_ERROR_DOM_MEDIA_ABORT_ERR, + NS_ERROR_DOM_MEDIA_NOT_ALLOWED_ERR = nsresult::NS_ERROR_DOM_MEDIA_NOT_ALLOWED_ERR, + NS_ERROR_DOM_MEDIA_NOT_SUPPORTED_ERR = nsresult::NS_ERROR_DOM_MEDIA_NOT_SUPPORTED_ERR, + + + NS_ERROR_DOM_MEDIA_DECODE_ERR = nsresult::NS_ERROR_DOM_MEDIA_DECODE_ERR, + NS_ERROR_DOM_MEDIA_FATAL_ERR = nsresult::NS_ERROR_DOM_MEDIA_FATAL_ERR, + NS_ERROR_DOM_MEDIA_METADATA_ERR = nsresult::NS_ERROR_DOM_MEDIA_METADATA_ERR, + NS_ERROR_DOM_MEDIA_OVERFLOW_ERR = nsresult::NS_ERROR_DOM_MEDIA_OVERFLOW_ERR, + NS_ERROR_DOM_MEDIA_END_OF_STREAM = nsresult::NS_ERROR_DOM_MEDIA_END_OF_STREAM, + NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA = nsresult::NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA, + NS_ERROR_DOM_MEDIA_CANCELED = nsresult::NS_ERROR_DOM_MEDIA_CANCELED, + NS_ERROR_DOM_MEDIA_MEDIASINK_ERR = nsresult::NS_ERROR_DOM_MEDIA_MEDIASINK_ERR, + NS_ERROR_DOM_MEDIA_DEMUXER_ERR = nsresult::NS_ERROR_DOM_MEDIA_DEMUXER_ERR, + NS_ERROR_DOM_MEDIA_CDM_ERR = nsresult::NS_ERROR_DOM_MEDIA_CDM_ERR, + NS_ERROR_DOM_MEDIA_NEED_NEW_DECODER = nsresult::NS_ERROR_DOM_MEDIA_NEED_NEW_DECODER, + NS_ERROR_DOM_MEDIA_INITIALIZING_DECODER = nsresult::NS_ERROR_DOM_MEDIA_INITIALIZING_DECODER, + + + NS_ERROR_DOM_MEDIA_CUBEB_INITIALIZATION_ERR = nsresult::NS_ERROR_DOM_MEDIA_CUBEB_INITIALIZATION_ERR, + + + + + + + NS_ERROR_UC_UPDATE_UNKNOWN = nsresult::NS_ERROR_UC_UPDATE_UNKNOWN, + NS_ERROR_UC_UPDATE_DUPLICATE_PREFIX = nsresult::NS_ERROR_UC_UPDATE_DUPLICATE_PREFIX, + NS_ERROR_UC_UPDATE_INFINITE_LOOP = nsresult::NS_ERROR_UC_UPDATE_INFINITE_LOOP, + NS_ERROR_UC_UPDATE_WRONG_REMOVAL_INDICES = nsresult::NS_ERROR_UC_UPDATE_WRONG_REMOVAL_INDICES, + NS_ERROR_UC_UPDATE_CHECKSUM_MISMATCH = nsresult::NS_ERROR_UC_UPDATE_CHECKSUM_MISMATCH, + NS_ERROR_UC_UPDATE_MISSING_CHECKSUM = nsresult::NS_ERROR_UC_UPDATE_MISSING_CHECKSUM, + NS_ERROR_UC_UPDATE_SHUTDOWNING = nsresult::NS_ERROR_UC_UPDATE_SHUTDOWNING, + NS_ERROR_UC_UPDATE_TABLE_NOT_FOUND = nsresult::NS_ERROR_UC_UPDATE_TABLE_NOT_FOUND, + NS_ERROR_UC_UPDATE_BUILD_PREFIX_FAILURE = nsresult::NS_ERROR_UC_UPDATE_BUILD_PREFIX_FAILURE, + NS_ERROR_UC_UPDATE_FAIL_TO_WRITE_DISK = nsresult::NS_ERROR_UC_UPDATE_FAIL_TO_WRITE_DISK, + NS_ERROR_UC_UPDATE_PROTOCOL_PARSER_ERROR = nsresult::NS_ERROR_UC_UPDATE_PROTOCOL_PARSER_ERROR, + + + + + + + + NS_ERROR_INTERNAL_ERRORRESULT_JS_EXCEPTION = nsresult::NS_ERROR_INTERNAL_ERRORRESULT_JS_EXCEPTION, + + NS_ERROR_INTERNAL_ERRORRESULT_DOMEXCEPTION = nsresult::NS_ERROR_INTERNAL_ERRORRESULT_DOMEXCEPTION, + + NS_ERROR_INTERNAL_ERRORRESULT_EXCEPTION_ON_JSCONTEXT = nsresult::NS_ERROR_INTERNAL_ERRORRESULT_EXCEPTION_ON_JSCONTEXT, + + NS_ERROR_INTERNAL_ERRORRESULT_TYPEERROR = nsresult::NS_ERROR_INTERNAL_ERRORRESULT_TYPEERROR, + + NS_ERROR_INTERNAL_ERRORRESULT_RANGEERROR = nsresult::NS_ERROR_INTERNAL_ERRORRESULT_RANGEERROR, +# 1029 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" + NS_ERROR_DOWNLOAD_COMPLETE = nsresult::NS_ERROR_DOWNLOAD_COMPLETE, + + + + NS_ERROR_DOWNLOAD_NOT_PARTIAL = nsresult::NS_ERROR_DOWNLOAD_NOT_PARTIAL, + NS_ERROR_UNORM_MOREOUTPUT = nsresult::NS_ERROR_UNORM_MOREOUTPUT, + + NS_ERROR_DOCSHELL_REQUEST_REJECTED = nsresult::NS_ERROR_DOCSHELL_REQUEST_REJECTED, + + + + + NS_ERROR_DOCUMENT_IS_PRINTMODE = nsresult::NS_ERROR_DOCUMENT_IS_PRINTMODE, + + NS_SUCCESS_DONT_FIXUP = nsresult::NS_SUCCESS_DONT_FIXUP, + + + + NS_SUCCESS_RESTART_APP = nsresult::NS_SUCCESS_RESTART_APP, + NS_SUCCESS_RESTART_APP_NOT_SAME_PROFILE = nsresult::NS_SUCCESS_RESTART_APP_NOT_SAME_PROFILE, + NS_SUCCESS_UNORM_NOTFOUND = nsresult::NS_SUCCESS_UNORM_NOTFOUND, + + + + + NS_ERROR_NOT_IN_TREE = nsresult::NS_ERROR_NOT_IN_TREE, + + + NS_OK_NO_NAME_CLAUSE_HANDLED = nsresult::NS_OK_NO_NAME_CLAUSE_HANDLED +# 142 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsError.h" 2 + +; +# 154 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsError.h" +inline uint32_t +NS_FAILED_impl(nsresult aErr) +{ + return static_cast(aErr) & 0x80000000; +} + + + + +static_assert(((nsresult)0) < ((nsresult)-1), + "nsresult must be an unsigned type"); +static_assert(sizeof(nsresult) == sizeof(uint32_t), + "nsresult must be 32 bits"); +# 193 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsError.h" +extern nsresult +NS_ErrorAccordingToNSPR(); + + + + + + +inline constexpr uint16_t +NS_ERROR_GET_CODE(nsresult aErr) +{ + return uint32_t(aErr) & 0xffff; +} +inline constexpr uint16_t +NS_ERROR_GET_MODULE(nsresult aErr) +{ + return ((uint32_t(aErr) >> 16) - 0x45) & 0x1fff; +} +inline bool +NS_ERROR_GET_SEVERITY(nsresult aErr) +{ + return uint32_t(aErr) >> 31; +} +# 232 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h" 2 + +typedef MozRefCountType nsrefcnt; +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTraceRefcnt.h" 2 + +class nsTraceRefcnt +{ +public: + static void Shutdown(); + + static nsresult DumpStatistics(); + + static void ResetStatistics(); + + static void WalkTheStack(FILE* aStream); + + + + + + + static void SetActivityIsLegal(bool aLegal); +}; + + + + +extern "C" void +NS_MeanAndStdDev(double aNumberOfValues, + double aSumOfValues, double aSumOfSquaredValues, + double* aMeanResult, double* aStdDevResult); +# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2 + + + + + + + + +extern "C" { +extern __attribute__((weak)) __attribute__((visibility("default"))) const char* gMozCrashReason; +} + + +static inline void +AnnotateMozCrashReason(const char* reason) +{ + gMozCrashReason = reason; +} + + + + + + +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 +# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3 +# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3 +# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 2 3 + +using std::abort; +using std::atexit; +using std::exit; + + + using std::at_quick_exit; + + + using std::quick_exit; + + + + +using std::div_t; +using std::ldiv_t; + +using std::abs; +using std::atof; +using std::atoi; +using std::atol; +using std::bsearch; +using std::calloc; +using std::div; +using std::free; +using std::getenv; +using std::labs; +using std::ldiv; +using std::malloc; + +using std::mblen; +using std::mbstowcs; +using std::mbtowc; + +using std::qsort; +using std::rand; +using std::realloc; +using std::srand; +using std::strtod; +using std::strtol; +using std::strtoul; +using std::system; + +using std::wcstombs; +using std::wctomb; +# 50 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2 +# 63 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" +# 1 "/usr/include/signal.h" 1 3 4 +# 30 "/usr/include/signal.h" 3 4 +extern "C" { + + +# 1 "/usr/include/bits/sigset.h" 1 3 4 +# 102 "/usr/include/bits/sigset.h" 3 4 +extern int __sigismember (const __sigset_t *, int); +extern int __sigaddset (__sigset_t *, int); +extern int __sigdelset (__sigset_t *, int); +# 33 "/usr/include/signal.h" 2 3 4 + + + + + + + +typedef __sig_atomic_t sig_atomic_t; +# 57 "/usr/include/signal.h" 3 4 +# 1 "/usr/include/bits/signum.h" 1 3 4 +# 58 "/usr/include/signal.h" 2 3 4 +# 75 "/usr/include/signal.h" 3 4 +# 1 "/usr/include/time.h" 1 3 4 +# 76 "/usr/include/signal.h" 2 3 4 + + + + +# 1 "/usr/include/bits/siginfo.h" 1 3 4 +# 24 "/usr/include/bits/siginfo.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 25 "/usr/include/bits/siginfo.h" 2 3 4 + + + + + + + +typedef union sigval + { + int sival_int; + void *sival_ptr; + } sigval_t; +# 58 "/usr/include/bits/siginfo.h" 3 4 +typedef __clock_t __sigchld_clock_t; + + + +typedef struct + { + int si_signo; + int si_errno; + + int si_code; + + union + { + int _pad[((128 / sizeof (int)) - 4)]; + + + struct + { + __pid_t si_pid; + __uid_t si_uid; + } _kill; + + + struct + { + int si_tid; + int si_overrun; + sigval_t si_sigval; + } _timer; + + + struct + { + __pid_t si_pid; + __uid_t si_uid; + sigval_t si_sigval; + } _rt; + + + struct + { + __pid_t si_pid; + __uid_t si_uid; + int si_status; + __sigchld_clock_t si_utime; + __sigchld_clock_t si_stime; + } _sigchld; + + + struct + { + void *si_addr; + short int si_addr_lsb; + struct + { + void *_lower; + void *_upper; + } si_addr_bnd; + } _sigfault; + + + struct + { + long int si_band; + int si_fd; + } _sigpoll; + + + struct + { + void *_call_addr; + int _syscall; + unsigned int _arch; + } _sigsys; + } _sifields; + } siginfo_t ; +# 160 "/usr/include/bits/siginfo.h" 3 4 +enum +{ + SI_ASYNCNL = -60, + + SI_TKILL = -6, + + SI_SIGIO, + + SI_ASYNCIO, + + SI_MESGQ, + + SI_TIMER, + + SI_QUEUE, + + SI_USER, + + SI_KERNEL = 0x80 + +}; + + + + +enum +{ + ILL_ILLOPC = 1, + + ILL_ILLOPN, + + ILL_ILLADR, + + ILL_ILLTRP, + + ILL_PRVOPC, + + ILL_PRVREG, + + ILL_COPROC, + + ILL_BADSTK + +}; + + +enum +{ + FPE_INTDIV = 1, + + FPE_INTOVF, + + FPE_FLTDIV, + + FPE_FLTOVF, + + FPE_FLTUND, + + FPE_FLTRES, + + FPE_FLTINV, + + FPE_FLTSUB + +}; + + +enum +{ + SEGV_MAPERR = 1, + + SEGV_ACCERR + +}; + + +enum +{ + BUS_ADRALN = 1, + + BUS_ADRERR, + + BUS_OBJERR, + + BUS_MCEERR_AR, + + BUS_MCEERR_AO + +}; + + + + +enum +{ + TRAP_BRKPT = 1, + + TRAP_TRACE + +}; + + + + +enum +{ + CLD_EXITED = 1, + + CLD_KILLED, + + CLD_DUMPED, + + CLD_TRAPPED, + + CLD_STOPPED, + + CLD_CONTINUED + +}; + + +enum +{ + POLL_IN = 1, + + POLL_OUT, + + POLL_MSG, + + POLL_ERR, + + POLL_PRI, + + POLL_HUP + +}; +# 320 "/usr/include/bits/siginfo.h" 3 4 +typedef struct sigevent + { + sigval_t sigev_value; + int sigev_signo; + int sigev_notify; + + union + { + int _pad[((64 / sizeof (int)) - 4)]; + + + + __pid_t _tid; + + struct + { + void (*_function) (sigval_t); + pthread_attr_t *_attribute; + } _sigev_thread; + } _sigev_un; + } sigevent_t; + + + + + + +enum +{ + SIGEV_SIGNAL = 0, + + SIGEV_NONE, + + SIGEV_THREAD, + + + SIGEV_THREAD_ID = 4 + +}; +# 81 "/usr/include/signal.h" 2 3 4 + + + + +typedef void (*__sighandler_t) (int); + + + + +extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler) + throw (); + +extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler) + throw (); + + + + + + + +extern __sighandler_t signal (int __sig, __sighandler_t __handler) + throw (); +# 119 "/usr/include/signal.h" 3 4 +extern __sighandler_t bsd_signal (int __sig, __sighandler_t __handler) + throw (); + + + + + + +extern int kill (__pid_t __pid, int __sig) throw (); + + + + + + +extern int killpg (__pid_t __pgrp, int __sig) throw (); + + + + +extern int raise (int __sig) throw (); + + + + +extern __sighandler_t ssignal (int __sig, __sighandler_t __handler) + throw (); +extern int gsignal (int __sig) throw (); + + + + +extern void psignal (int __sig, const char *__s); + + +extern void psiginfo (const siginfo_t *__pinfo, const char *__s); +# 168 "/usr/include/signal.h" 3 4 +extern int sigpause (int __sig) __asm__ ("__xpg_sigpause"); +# 187 "/usr/include/signal.h" 3 4 +extern int sigblock (int __mask) throw () __attribute__ ((__deprecated__)); + + +extern int sigsetmask (int __mask) throw () __attribute__ ((__deprecated__)); + + +extern int siggetmask (void) throw () __attribute__ ((__deprecated__)); +# 202 "/usr/include/signal.h" 3 4 +typedef __sighandler_t sighandler_t; + + + + +typedef __sighandler_t sig_t; + + + + + +extern int sigemptyset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1))); + + +extern int sigfillset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1))); + + +extern int sigaddset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1))); + + +extern int sigdelset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1))); + + +extern int sigismember (const sigset_t *__set, int __signo) + throw () __attribute__ ((__nonnull__ (1))); + + + +extern int sigisemptyset (const sigset_t *__set) throw () __attribute__ ((__nonnull__ (1))); + + +extern int sigandset (sigset_t *__set, const sigset_t *__left, + const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3))); + + +extern int sigorset (sigset_t *__set, const sigset_t *__left, + const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3))); + + + + + +# 1 "/usr/include/bits/sigaction.h" 1 3 4 +# 24 "/usr/include/bits/sigaction.h" 3 4 +struct sigaction + { + + + union + { + + __sighandler_t sa_handler; + + void (*sa_sigaction) (int, siginfo_t *, void *); + } + __sigaction_handler; + + + + + + + + __sigset_t sa_mask; + + + int sa_flags; + + + void (*sa_restorer) (void); + }; +# 244 "/usr/include/signal.h" 2 3 4 + + +extern int sigprocmask (int __how, const sigset_t *__restrict __set, + sigset_t *__restrict __oset) throw (); + + + + + + +extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ (1))); + + +extern int sigaction (int __sig, const struct sigaction *__restrict __act, + struct sigaction *__restrict __oact) throw (); + + +extern int sigpending (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1))); + + + + + + +extern int sigwait (const sigset_t *__restrict __set, int *__restrict __sig) + __attribute__ ((__nonnull__ (1, 2))); + + + + + + +extern int sigwaitinfo (const sigset_t *__restrict __set, + siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1))); + + + + + + +extern int sigtimedwait (const sigset_t *__restrict __set, + siginfo_t *__restrict __info, + const struct timespec *__restrict __timeout) + __attribute__ ((__nonnull__ (1))); + + + +extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val) + throw (); +# 301 "/usr/include/signal.h" 3 4 +extern const char *const _sys_siglist[65]; +extern const char *const sys_siglist[65]; + + + + +# 1 "/usr/include/bits/sigcontext.h" 1 3 4 +# 29 "/usr/include/bits/sigcontext.h" 3 4 +struct _fpx_sw_bytes +{ + __uint32_t magic1; + __uint32_t extended_size; + __uint64_t xstate_bv; + __uint32_t xstate_size; + __uint32_t padding[7]; +}; + +struct _fpreg +{ + unsigned short significand[4]; + unsigned short exponent; +}; + +struct _fpxreg +{ + unsigned short significand[4]; + unsigned short exponent; + unsigned short padding[3]; +}; + +struct _xmmreg +{ + __uint32_t element[4]; +}; +# 121 "/usr/include/bits/sigcontext.h" 3 4 +struct _fpstate +{ + + __uint16_t cwd; + __uint16_t swd; + __uint16_t ftw; + __uint16_t fop; + __uint64_t rip; + __uint64_t rdp; + __uint32_t mxcsr; + __uint32_t mxcr_mask; + struct _fpxreg _st[8]; + struct _xmmreg _xmm[16]; + __uint32_t padding[24]; +}; + +struct sigcontext +{ + __uint64_t r8; + __uint64_t r9; + __uint64_t r10; + __uint64_t r11; + __uint64_t r12; + __uint64_t r13; + __uint64_t r14; + __uint64_t r15; + __uint64_t rdi; + __uint64_t rsi; + __uint64_t rbp; + __uint64_t rbx; + __uint64_t rdx; + __uint64_t rax; + __uint64_t rcx; + __uint64_t rsp; + __uint64_t rip; + __uint64_t eflags; + unsigned short cs; + unsigned short gs; + unsigned short fs; + unsigned short __pad0; + __uint64_t err; + __uint64_t trapno; + __uint64_t oldmask; + __uint64_t cr2; + __extension__ union + { + struct _fpstate * fpstate; + __uint64_t __fpstate_word; + }; + __uint64_t __reserved1 [8]; +}; + + + +struct _xsave_hdr +{ + __uint64_t xstate_bv; + __uint64_t reserved1[2]; + __uint64_t reserved2[5]; +}; + +struct _ymmh_state +{ + __uint32_t ymmh_space[64]; +}; + +struct _xstate +{ + struct _fpstate fpstate; + struct _xsave_hdr xstate_hdr; + struct _ymmh_state ymmh; +}; +# 307 "/usr/include/signal.h" 2 3 4 + + +extern int sigreturn (struct sigcontext *__scp) throw (); + + + + + + + +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4 +# 317 "/usr/include/signal.h" 2 3 4 + + + + +extern int siginterrupt (int __sig, int __interrupt) throw (); + + +# 1 "/usr/include/bits/sigstack.h" 1 3 4 +# 25 "/usr/include/bits/sigstack.h" 3 4 +struct sigstack + { + void *ss_sp; + int ss_onstack; + }; + + + +enum +{ + SS_ONSTACK = 1, + + SS_DISABLE + +}; +# 49 "/usr/include/bits/sigstack.h" 3 4 +typedef struct sigaltstack + { + void *ss_sp; + int ss_flags; + size_t ss_size; + } stack_t; +# 324 "/usr/include/signal.h" 2 3 4 + + +# 1 "/usr/include/sys/ucontext.h" 1 3 4 +# 22 "/usr/include/sys/ucontext.h" 3 4 +# 1 "/usr/include/signal.h" 1 3 4 +# 23 "/usr/include/sys/ucontext.h" 2 3 4 + + + + + + + + +__extension__ typedef long long int greg_t; + + + + + +typedef greg_t gregset_t[23]; + + + +enum +{ + REG_R8 = 0, + + REG_R9, + + REG_R10, + + REG_R11, + + REG_R12, + + REG_R13, + + REG_R14, + + REG_R15, + + REG_RDI, + + REG_RSI, + + REG_RBP, + + REG_RBX, + + REG_RDX, + + REG_RAX, + + REG_RCX, + + REG_RSP, + + REG_RIP, + + REG_EFL, + + REG_CSGSFS, + + REG_ERR, + + REG_TRAPNO, + + REG_OLDMASK, + + REG_CR2 + +}; + + +struct _libc_fpxreg +{ + unsigned short int significand[4]; + unsigned short int exponent; + unsigned short int padding[3]; +}; + +struct _libc_xmmreg +{ + __uint32_t element[4]; +}; + +struct _libc_fpstate +{ + + __uint16_t cwd; + __uint16_t swd; + __uint16_t ftw; + __uint16_t fop; + __uint64_t rip; + __uint64_t rdp; + __uint32_t mxcsr; + __uint32_t mxcr_mask; + struct _libc_fpxreg _st[8]; + struct _libc_xmmreg _xmm[16]; + __uint32_t padding[24]; +}; + + +typedef struct _libc_fpstate *fpregset_t; + + +typedef struct + { + gregset_t gregs; + + fpregset_t fpregs; + __extension__ unsigned long long __reserved1 [8]; +} mcontext_t; + + +typedef struct ucontext + { + unsigned long int uc_flags; + struct ucontext *uc_link; + stack_t uc_stack; + mcontext_t uc_mcontext; + __sigset_t uc_sigmask; + struct _libc_fpstate __fpregs_mem; + } ucontext_t; +# 327 "/usr/include/signal.h" 2 3 4 + + + + + +extern int sigstack (struct sigstack *__ss, struct sigstack *__oss) + throw () __attribute__ ((__deprecated__)); + + + +extern int sigaltstack (const struct sigaltstack *__restrict __ss, + struct sigaltstack *__restrict __oss) throw (); + + + + + + + +extern int sighold (int __sig) throw (); + + +extern int sigrelse (int __sig) throw (); + + +extern int sigignore (int __sig) throw (); + + +extern __sighandler_t sigset (int __sig, __sighandler_t __disp) throw (); + + + + + + + +# 1 "/usr/include/bits/sigthread.h" 1 3 4 +# 30 "/usr/include/bits/sigthread.h" 3 4 +extern int pthread_sigmask (int __how, + const __sigset_t *__restrict __newmask, + __sigset_t *__restrict __oldmask)throw (); + + +extern int pthread_kill (pthread_t __threadid, int __signo) throw (); + + + +extern int pthread_sigqueue (pthread_t __threadid, int __signo, + const union sigval __value) throw (); +# 363 "/usr/include/signal.h" 2 3 4 + + + + + + +extern int __libc_current_sigrtmin (void) throw (); + +extern int __libc_current_sigrtmax (void) throw (); + + + +} +# 64 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2 +# 141 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" +extern "C" { +# 151 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" +__attribute__ ((__unused__)) static __attribute__ ((cold)) __attribute__((noinline)) void +MOZ_ReportAssertionFailure(const char* aStr, const char* aFilename, int aLine) + +{ + + + + + + fprintf(stderr, "Assertion failure: %s, at %s:%d\n", aStr, aFilename, aLine); + + nsTraceRefcnt::WalkTheStack(stderr); + + fflush(stderr); + +} + +__attribute__ ((__unused__)) static __attribute__ ((cold)) __attribute__((noinline)) void +MOZ_ReportCrash(const char* aStr, const char* aFilename, int aLine) + +{ + + + + + fprintf(stderr, "Hit MOZ_CRASH(%s) at %s:%d\n", aStr, aFilename, aLine); + + nsTraceRefcnt::WalkTheStack(stderr); + + fflush(stderr); + +} +# 283 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" +__attribute__((weak)) __attribute__((visibility("default"))) __attribute__ ((cold)) __attribute__((noreturn)) __attribute__((noinline)) void +MOZ_CrashOOL(int aLine, const char* aReason); + + + + + + + +static const size_t sPrintfMaxArgs = 4; +static const size_t sPrintfCrashReasonSize = 1024; + + +__attribute__((weak)) __attribute__((visibility("default"))) __attribute__ ((cold)) __attribute__((noreturn)) __attribute__((noinline)) __attribute__ ((format (printf, 2, 3))) void +MOZ_CrashPrintf(int aLine, const char* aFormat, ...); +# 326 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" +} +# 376 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" +namespace mozilla { +namespace detail { + +template +struct AssertionConditionType +{ + typedef typename RemoveReference::Type ValueT; + static_assert(!IsArray::value, + "Expected boolean assertion condition, got an array or a " + "string!"); + static_assert(!IsFunction::value, + "Expected boolean assertion condition, got a function! Did " + "you intend to call that function?"); + static_assert(!IsFloatingPoint::value, + "It's often a bad idea to assert that a floating-point number " + "is nonzero, because such assertions tend to intermittently " + "fail. Shouldn't your code gracefully handle this case instead " + "of asserting? Anyway, if you really want to do that, write an " + "explicit boolean condition, like !!x or x!=0."); + + static const bool isValid = true; +}; + +} +} +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h" 2 + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Move.h" 1 +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Move.h" +namespace mozilla { +# 199 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Move.h" +template +inline typename RemoveReference::Type&& +Move(T&& aX) +{ + return static_cast::Type&&>(aX); +} + + + + + +template +inline T&& +Forward(typename RemoveReference::Type& aX) +{ + return static_cast(aX); +} + +template +inline T&& +Forward(typename RemoveReference::Type&& aX) +{ + static_assert(!IsLvalueReference::value, + "misuse of Forward detected! try the other overload"); + return static_cast(aX); +} + + +template +inline void +Swap(T& aX, T& aY) +{ + T tmp(Move(aX)); + aX = Move(aY); + aY = Move(tmp); +} + +} +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h" 2 + +namespace mozilla { + +struct unused_t; + +} +# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h" +template +struct already_AddRefed +{ +# 68 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h" + already_AddRefed() : mRawPtr(nullptr) {} + + + + typedef void (already_AddRefed::* MatchNullptr)(double, float); + already_AddRefed(MatchNullptr aRawPtr) : mRawPtr(nullptr) {} + + explicit already_AddRefed(T* aRawPtr) : mRawPtr(aRawPtr) {} + + + already_AddRefed(const already_AddRefed& aOther) = delete; + already_AddRefed& operator=(const already_AddRefed& aOther) = delete; + + already_AddRefed(already_AddRefed&& aOther) : mRawPtr(aOther.take()) {} + + already_AddRefed& operator=(already_AddRefed&& aOther) + { + mRawPtr = aOther.take(); + return *this; + } +# 106 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h" + template + already_AddRefed(already_AddRefed&& aOther) : mRawPtr(aOther.take()) {} + + ~already_AddRefed() { do { } while (0); } + + + + + + friend void operator<<(const mozilla::unused_t& aUnused, + const already_AddRefed& aRhs) + { + auto mutableAlreadyAddRefed = const_cast*>(&aRhs); + aUnused << mutableAlreadyAddRefed->take(); + } + + __attribute__ ((warn_unused_result)) T* take() + { + T* rawPtr = mRawPtr; + mRawPtr = nullptr; + return rawPtr; + } +# 143 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h" + template + already_AddRefed downcast() + { + U* tmp = static_cast(mRawPtr); + mRawPtr = nullptr; + return already_AddRefed(tmp); + } + +private: + T* mRawPtr; +}; +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h" 2 + + + + + + + +class nsCOMPtr_helper; + +namespace mozilla { +template class OwningNonNull; +template class StaticRefPtr; +# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h" +template +struct RefPtrTraits +{ + static void AddRef(U* aPtr) { + aPtr->AddRef(); + } + static void Release(U* aPtr) { + aPtr->Release(); + } +}; + +} + +template +class RefPtr +{ +private: + void + assign_with_AddRef(T* aRawPtr) + { + if (aRawPtr) { + ConstRemovingRefPtrTraits::AddRef(aRawPtr); + } + assign_assuming_AddRef(aRawPtr); + } + + void + assign_assuming_AddRef(T* aNewPtr) + { + T* oldPtr = mRawPtr; + mRawPtr = aNewPtr; + if (oldPtr) { + ConstRemovingRefPtrTraits::Release(oldPtr); + } + } + +private: + T* mRawPtr; + +public: + typedef T element_type; + + ~RefPtr() + { + if (mRawPtr) { + ConstRemovingRefPtrTraits::Release(mRawPtr); + } + } + + + + RefPtr() + : mRawPtr(nullptr) + + { + } + + RefPtr(const RefPtr& aSmartPtr) + : mRawPtr(aSmartPtr.mRawPtr) + + { + if (mRawPtr) { + ConstRemovingRefPtrTraits::AddRef(mRawPtr); + } + } + + RefPtr(RefPtr&& aRefPtr) + : mRawPtr(aRefPtr.mRawPtr) + { + aRefPtr.mRawPtr = nullptr; + } + + + + RefPtr(T* aRawPtr) + : mRawPtr(aRawPtr) + { + if (mRawPtr) { + ConstRemovingRefPtrTraits::AddRef(mRawPtr); + } + } + + RefPtr(decltype(nullptr)) + : mRawPtr(nullptr) + { + } + + template + RefPtr(already_AddRefed& aSmartPtr) + : mRawPtr(aSmartPtr.take()) + + { + } + + template + RefPtr(already_AddRefed&& aSmartPtr) + : mRawPtr(aSmartPtr.take()) + + { + } + + template + RefPtr(const RefPtr& aSmartPtr) + : mRawPtr(aSmartPtr.get()) + + { + if (mRawPtr) { + ConstRemovingRefPtrTraits::AddRef(mRawPtr); + } + } + + template + RefPtr(RefPtr&& aSmartPtr) + : mRawPtr(aSmartPtr.forget().take()) + + { + } + + RefPtr(const nsCOMPtr_helper& aHelper); + + + template + RefPtr(const mozilla::OwningNonNull& aOther); + + + template + RefPtr(const mozilla::StaticRefPtr& aOther); + + + + RefPtr& + operator=(decltype(nullptr)) + { + assign_assuming_AddRef(nullptr); + return *this; + } + + RefPtr& + operator=(const RefPtr& aRhs) + + { + assign_with_AddRef(aRhs.mRawPtr); + return *this; + } + + template + RefPtr& + operator=(const RefPtr& aRhs) + + { + assign_with_AddRef(aRhs.get()); + return *this; + } + + RefPtr& + operator=(T* aRhs) + + { + assign_with_AddRef(aRhs); + return *this; + } + + template + RefPtr& + operator=(already_AddRefed& aRhs) + + { + assign_assuming_AddRef(aRhs.take()); + return *this; + } + + template + RefPtr& + operator=(already_AddRefed && aRhs) + + { + assign_assuming_AddRef(aRhs.take()); + return *this; + } + + RefPtr& operator=(const nsCOMPtr_helper& aHelper); + + RefPtr& + operator=(RefPtr && aRefPtr) + { + assign_assuming_AddRef(aRefPtr.mRawPtr); + aRefPtr.mRawPtr = nullptr; + return *this; + } + + + template + RefPtr& + operator=(const mozilla::OwningNonNull& aOther); + + + template + RefPtr& + operator=(const mozilla::StaticRefPtr& aOther); + + + + void + swap(RefPtr& aRhs) + + { + T* temp = aRhs.mRawPtr; + aRhs.mRawPtr = mRawPtr; + mRawPtr = temp; + } + + void + swap(T*& aRhs) + + { + T* temp = aRhs; + aRhs = mRawPtr; + mRawPtr = temp; + } + + already_AddRefed + + forget() + + + { + T* temp = nullptr; + swap(temp); + return already_AddRefed(temp); + } + + template + void + forget(I** aRhs) + + + + + { + do { } while (0); + *aRhs = mRawPtr; + mRawPtr = nullptr; + } + + T* + get() const + + + + + { + return const_cast(mRawPtr); + } + + operator T*() const & +# 296 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h" + { + return get(); + } + + + + + operator T*() const && = delete; + + + + + explicit operator bool() const { return !!mRawPtr; } + bool operator!() const { return !mRawPtr; } + + T* + operator->() const + { + do { } while (0); + + return get(); + } + + template + class Proxy + { + typedef R (T::*member_function)(Args...); + T* mRawPtr; + member_function mFunction; + public: + Proxy(T* aRawPtr, member_function aFunction) + : mRawPtr(aRawPtr), + mFunction(aFunction) + { + } + template + R operator()(ActualArgs&&... aArgs) + { + return ((*mRawPtr).*mFunction)(mozilla::Forward(aArgs)...); + } + }; + + template + Proxy operator->*(R (T::*aFptr)(Args...)) const + { + do { } while (0); + + return Proxy(get(), aFptr); + } + + RefPtr* + get_address() + + + { + return this; + } + + const RefPtr* + get_address() const + + + { + return this; + } + +public: + T& + operator*() const + { + do { } while (0); + + return *get(); + } + + T** + StartAssignment() + { + assign_assuming_AddRef(nullptr); + return reinterpret_cast(&mRawPtr); + } +private: +# 388 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h" + template + struct ConstRemovingRefPtrTraits + { + static void AddRef(U* aPtr) { + mozilla::RefPtrTraits::AddRef(aPtr); + } + static void Release(U* aPtr) { + mozilla::RefPtrTraits::Release(aPtr); + } + }; + template + struct ConstRemovingRefPtrTraits + { + static void AddRef(const U* aPtr) { + mozilla::RefPtrTraits::AddRef(const_cast(aPtr)); + } + static void Release(const U* aPtr) { + mozilla::RefPtrTraits::Release(const_cast(aPtr)); + } + }; +}; + +class nsCycleCollectionTraversalCallback; +template +void +CycleCollectionNoteChild(nsCycleCollectionTraversalCallback& aCallback, + T* aChild, const char* aName, uint32_t aFlags); + +template +inline void +ImplCycleCollectionUnlink(RefPtr& aField) +{ + aField = nullptr; +} + +template +inline void +ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback, + RefPtr& aField, + const char* aName, + uint32_t aFlags = 0) +{ + CycleCollectionNoteChild(aCallback, aField.get(), aName, aFlags); +} + +template +inline RefPtr* +address_of(RefPtr& aPtr) +{ + return aPtr.get_address(); +} + +template +inline const RefPtr* +address_of(const RefPtr& aPtr) +{ + return aPtr.get_address(); +} + +template +class RefPtrGetterAddRefs +# 466 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h" +{ +public: + explicit + RefPtrGetterAddRefs(RefPtr& aSmartPtr) + : mTargetSmartPtr(aSmartPtr) + { + + } + + operator void**() + { + return reinterpret_cast(mTargetSmartPtr.StartAssignment()); + } + + operator T**() + { + return mTargetSmartPtr.StartAssignment(); + } + + T*& + operator*() + { + return *(mTargetSmartPtr.StartAssignment()); + } + +private: + RefPtr& mTargetSmartPtr; +}; + +template +inline RefPtrGetterAddRefs +getter_AddRefs(RefPtr& aSmartPtr) + + + + +{ + return RefPtrGetterAddRefs(aSmartPtr); +} + + + + +template +inline bool +operator==(const RefPtr& aLhs, const RefPtr& aRhs) +{ + return static_cast(aLhs.get()) == static_cast(aRhs.get()); +} + + +template +inline bool +operator!=(const RefPtr& aLhs, const RefPtr& aRhs) +{ + return static_cast(aLhs.get()) != static_cast(aRhs.get()); +} + + + + +template +inline bool +operator==(const RefPtr& aLhs, const U* aRhs) +{ + return static_cast(aLhs.get()) == static_cast(aRhs); +} + +template +inline bool +operator==(const U* aLhs, const RefPtr& aRhs) +{ + return static_cast(aLhs) == static_cast(aRhs.get()); +} + +template +inline bool +operator!=(const RefPtr& aLhs, const U* aRhs) +{ + return static_cast(aLhs.get()) != static_cast(aRhs); +} + +template +inline bool +operator!=(const U* aLhs, const RefPtr& aRhs) +{ + return static_cast(aLhs) != static_cast(aRhs.get()); +} + +template +inline bool +operator==(const RefPtr& aLhs, U* aRhs) +{ + return static_cast(aLhs.get()) == const_cast(aRhs); +} + +template +inline bool +operator==(U* aLhs, const RefPtr& aRhs) +{ + return const_cast(aLhs) == static_cast(aRhs.get()); +} + +template +inline bool +operator!=(const RefPtr& aLhs, U* aRhs) +{ + return static_cast(aLhs.get()) != const_cast(aRhs); +} + +template +inline bool +operator!=(U* aLhs, const RefPtr& aRhs) +{ + return const_cast(aLhs) != static_cast(aRhs.get()); +} + + + +template +inline bool +operator==(const RefPtr& aLhs, decltype(nullptr)) +{ + return aLhs.get() == nullptr; +} + +template +inline bool +operator==(decltype(nullptr), const RefPtr& aRhs) +{ + return nullptr == aRhs.get(); +} + +template +inline bool +operator!=(const RefPtr& aLhs, decltype(nullptr)) +{ + return aLhs.get() != nullptr; +} + +template +inline bool +operator!=(decltype(nullptr), const RefPtr& aRhs) +{ + return nullptr != aRhs.get(); +} + + + +template +inline already_AddRefed +do_AddRef(T* aObj) +{ + RefPtr ref(aObj); + return ref.forget(); +} + +template +inline already_AddRefed +do_AddRef(const RefPtr& aObj) +{ + RefPtr ref(aObj); + return ref.forget(); +} + +namespace mozilla { +# 642 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h" +template +already_AddRefed +MakeAndAddRef(Args&&... aArgs) +{ + RefPtr p(new T(Forward(aArgs)...)); + return p.forget(); +} + +} +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 2 + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h" 1 +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Pair.h" 1 +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Pair.h" +namespace mozilla { + +namespace detail { + +enum StorageType { AsBase, AsMember }; +# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Pair.h" +template::value ? detail::AsBase : detail::AsMember, + detail::StorageType = + IsEmpty::value && !IsBaseOf::value && !IsBaseOf::value + ? detail::AsBase + : detail::AsMember> +struct PairHelper; + +template +struct PairHelper +{ +protected: + template + PairHelper(AArg&& aA, BArg&& aB) + : mFirstA(Forward(aA)), + mSecondB(Forward(aB)) + {} + + A& first() { return mFirstA; } + const A& first() const { return mFirstA; } + B& second() { return mSecondB; } + const B& second() const { return mSecondB; } + + void swap(PairHelper& aOther) + { + Swap(mFirstA, aOther.mFirstA); + Swap(mSecondB, aOther.mSecondB); + } + +private: + A mFirstA; + B mSecondB; +}; + +template +struct PairHelper : private B +{ +protected: + template + PairHelper(AArg&& aA, BArg&& aB) + : B(Forward(aB)), + mFirstA(Forward(aA)) + {} + + A& first() { return mFirstA; } + const A& first() const { return mFirstA; } + B& second() { return *this; } + const B& second() const { return *this; } + + void swap(PairHelper& aOther) + { + Swap(mFirstA, aOther.mFirstA); + Swap(static_cast(*this), static_cast(aOther)); + } + +private: + A mFirstA; +}; + +template +struct PairHelper : private A +{ +protected: + template + PairHelper(AArg&& aA, BArg&& aB) + : A(Forward(aA)), + mSecondB(Forward(aB)) + {} + + A& first() { return *this; } + const A& first() const { return *this; } + B& second() { return mSecondB; } + const B& second() const { return mSecondB; } + + void swap(PairHelper& aOther) + { + Swap(static_cast(*this), static_cast(aOther)); + Swap(mSecondB, aOther.mSecondB); + } + +private: + B mSecondB; +}; + +template +struct PairHelper : private A, private B +{ +protected: + template + PairHelper(AArg&& aA, BArg&& aB) + : A(Forward(aA)), + B(Forward(aB)) + {} + + A& first() { return static_cast(*this); } + const A& first() const { return static_cast(*this); } + B& second() { return static_cast(*this); } + const B& second() const { return static_cast(*this); } + + void swap(PairHelper& aOther) + { + Swap(static_cast(*this), static_cast(aOther)); + Swap(static_cast(*this), static_cast(aOther)); + } +}; + +} +# 151 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Pair.h" +template +struct Pair + : private detail::PairHelper +{ + typedef typename detail::PairHelper Base; + +public: + template + Pair(AArg&& aA, BArg&& aB) + : Base(Forward(aA), Forward(aB)) + {} + + Pair(Pair&& aOther) + : Base(Move(aOther.first()), Move(aOther.second())) + { } + + Pair(const Pair& aOther) = default; + + Pair& operator=(Pair&& aOther) + { + do { } while (0); + + first() = Move(aOther.first()); + second() = Move(aOther.second()); + + return *this; + } + + Pair& operator=(const Pair& aOther) = default; + + + using Base::first; + + using Base::second; + + + void swap(Pair& aOther) { Base::swap(aOther); } +}; + +template +void +Swap(Pair& aX, Pair& aY) +{ + aX.swap(aY); +} +# 205 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Pair.h" +template +Pair::Type>::Type, + typename RemoveCV::Type>::Type> +MakePair(A&& aA, B&& aB) +{ + return + Pair::Type>::Type, + typename RemoveCV::Type>::Type>( + Forward(aA), + Forward(aB)); +} + +} +# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h" 2 + + +namespace mozilla { + +template class DefaultDelete; +template> class UniquePtr; + +} + +namespace mozilla { + +namespace detail { + +struct HasPointerTypeHelper +{ + template static double Test(...); + template static char Test(typename U::pointer* = 0); +}; + +template +class HasPointerType : public IntegralConstant(0)) == 1> +{ +}; + +template ::value> +struct PointerTypeImpl +{ + typedef typename D::pointer Type; +}; + +template +struct PointerTypeImpl +{ + typedef T* Type; +}; + +template +struct PointerType +{ + typedef typename PointerTypeImpl::Type>::Type Type; +}; + +} +# 187 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h" +template +class UniquePtr +{ +public: + typedef T ElementType; + typedef D DeleterType; + typedef typename detail::PointerType::Type Pointer; + +private: + Pair mTuple; + + Pointer& ptr() { return mTuple.first(); } + const Pointer& ptr() const { return mTuple.first(); } + + DeleterType& del() { return mTuple.second(); } + const DeleterType& del() const { return mTuple.second(); } + +public: + + + + constexpr UniquePtr() + : mTuple(static_cast(nullptr), DeleterType()) + { + static_assert(!IsPointer::value, "must provide a deleter instance"); + static_assert(!IsReference::value, "must provide a deleter instance"); + } + + + + + explicit UniquePtr(Pointer aPtr) + : mTuple(aPtr, DeleterType()) + { + static_assert(!IsPointer::value, "must provide a deleter instance"); + static_assert(!IsReference::value, "must provide a deleter instance"); + } + + UniquePtr(Pointer aPtr, + typename Conditional::value, + D, + const D&>::Type aD1) + : mTuple(aPtr, aD1) + {} +# 254 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h" + UniquePtr(Pointer aPtr, + typename RemoveReference::Type&& aD2) + : mTuple(aPtr, Move(aD2)) + { + static_assert(!IsReference::value, + "rvalue deleter can't be stored by reference"); + } + + UniquePtr(UniquePtr&& aOther) + : mTuple(aOther.release(), Forward(aOther.get_deleter())) + {} + + + UniquePtr(decltype(nullptr)) + : mTuple(nullptr, DeleterType()) + { + static_assert(!IsPointer::value, "must provide a deleter instance"); + static_assert(!IsReference::value, "must provide a deleter instance"); + } + + template + + UniquePtr(UniquePtr&& aOther, + typename EnableIf::Pointer, + Pointer>::value && + !IsArray::value && + (IsReference::value + ? IsSame::value + : IsConvertible::value), + int>::Type aDummy = 0) + : mTuple(aOther.release(), Forward(aOther.get_deleter())) + { + } + + ~UniquePtr() { reset(nullptr); } + + UniquePtr& operator=(UniquePtr&& aOther) + { + reset(aOther.release()); + get_deleter() = Forward(aOther.get_deleter()); + return *this; + } + + template + UniquePtr& operator=(UniquePtr&& aOther) + { + static_assert(IsConvertible::Pointer, + Pointer>::value, + "incompatible UniquePtr pointees"); + static_assert(!IsArray::value, + "can't assign from UniquePtr holding an array"); + + reset(aOther.release()); + get_deleter() = Forward(aOther.get_deleter()); + return *this; + } + + UniquePtr& operator=(decltype(nullptr)) + { + reset(nullptr); + return *this; + } + + T& operator*() const { return *get(); } + Pointer operator->() const + { + do { } while (0); + return get(); + } + + explicit operator bool() const { return get() != nullptr; } + + Pointer get() const { return ptr(); } + + DeleterType& get_deleter() { return del(); } + const DeleterType& get_deleter() const { return del(); } + + __attribute__ ((warn_unused_result)) Pointer release() + { + Pointer p = ptr(); + ptr() = nullptr; + return p; + } + + void reset(Pointer aPtr = Pointer()) + { + Pointer old = ptr(); + ptr() = aPtr; + if (old != nullptr) { + get_deleter()(old); + } + } + + void swap(UniquePtr& aOther) + { + mTuple.swap(aOther.mTuple); + } + + UniquePtr(const UniquePtr& aOther) = delete; + void operator=(const UniquePtr& aOther) = delete; +}; + + + + + +template +class UniquePtr +{ +public: + typedef T* Pointer; + typedef T ElementType; + typedef D DeleterType; + +private: + Pair mTuple; + +public: + + + + constexpr UniquePtr() + : mTuple(static_cast(nullptr), DeleterType()) + { + static_assert(!IsPointer::value, "must provide a deleter instance"); + static_assert(!IsReference::value, "must provide a deleter instance"); + } + + + + + explicit UniquePtr(Pointer aPtr) + : mTuple(aPtr, DeleterType()) + { + static_assert(!IsPointer::value, "must provide a deleter instance"); + static_assert(!IsReference::value, "must provide a deleter instance"); + } + + + + + + + template + UniquePtr(U&& aU, + typename EnableIf::value && + IsConvertible::value, + int>::Type aDummy = 0) + = delete; + + UniquePtr(Pointer aPtr, + typename Conditional::value, + D, + const D&>::Type aD1) + : mTuple(aPtr, aD1) + {} + + + + + + UniquePtr(Pointer aPtr, + typename RemoveReference::Type&& aD2) + : mTuple(aPtr, Move(aD2)) + { + static_assert(!IsReference::value, + "rvalue deleter can't be stored by reference"); + } + + + template + UniquePtr(U&& aU, V&& aV, + typename EnableIf::value && + IsConvertible::value, + int>::Type aDummy = 0) + = delete; + + UniquePtr(UniquePtr&& aOther) + : mTuple(aOther.release(), Forward(aOther.get_deleter())) + {} + + + UniquePtr(decltype(nullptr)) + : mTuple(nullptr, DeleterType()) + { + static_assert(!IsPointer::value, "must provide a deleter instance"); + static_assert(!IsReference::value, "must provide a deleter instance"); + } + + ~UniquePtr() { reset(nullptr); } + + UniquePtr& operator=(UniquePtr&& aOther) + { + reset(aOther.release()); + get_deleter() = Forward(aOther.get_deleter()); + return *this; + } + + UniquePtr& operator=(decltype(nullptr)) + { + reset(); + return *this; + } + + explicit operator bool() const { return get() != nullptr; } + + T& operator[](decltype(sizeof(int)) aIndex) const { return get()[aIndex]; } + Pointer get() const { return mTuple.first(); } + + DeleterType& get_deleter() { return mTuple.second(); } + const DeleterType& get_deleter() const { return mTuple.second(); } + + __attribute__ ((warn_unused_result)) Pointer release() + { + Pointer p = mTuple.first(); + mTuple.first() = nullptr; + return p; + } + + void reset(Pointer aPtr = Pointer()) + { + Pointer old = mTuple.first(); + mTuple.first() = aPtr; + if (old != nullptr) { + mTuple.second()(old); + } + } + + void reset(decltype(nullptr)) + { + Pointer old = mTuple.first(); + mTuple.first() = nullptr; + if (old != nullptr) { + mTuple.second()(old); + } + } + + template + void reset(U) = delete; + + void swap(UniquePtr& aOther) { mTuple.swap(aOther.mTuple); } + + UniquePtr(const UniquePtr& aOther) = delete; + void operator=(const UniquePtr& aOther) = delete; +}; +# 513 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h" +template +class DefaultDelete +{ +public: + constexpr DefaultDelete() {} + + template + DefaultDelete(const DefaultDelete& aOther, + typename EnableIf::value, + int>::Type aDummy = 0) + {} + + void operator()(T* aPtr) const + { + static_assert(sizeof(T) > 0, "T must be complete"); + delete aPtr; + } +}; + + +template +class DefaultDelete +{ +public: + constexpr DefaultDelete() {} + + void operator()(T* aPtr) const + { + static_assert(sizeof(T) > 0, "T must be complete"); + delete[] aPtr; + } + + template + void operator()(U* aPtr) const = delete; +}; + +template +void +Swap(UniquePtr& aX, UniquePtr& aY) +{ + aX.swap(aY); +} + +template +bool +operator==(const UniquePtr& aX, const UniquePtr& aY) +{ + return aX.get() == aY.get(); +} + +template +bool +operator!=(const UniquePtr& aX, const UniquePtr& aY) +{ + return aX.get() != aY.get(); +} + +template +bool +operator==(const UniquePtr& aX, decltype(nullptr)) +{ + return !aX; +} + +template +bool +operator==(decltype(nullptr), const UniquePtr& aX) +{ + return !aX; +} + +template +bool +operator!=(const UniquePtr& aX, decltype(nullptr)) +{ + return bool(aX); +} + +template +bool +operator!=(decltype(nullptr), const UniquePtr& aX) +{ + return bool(aX); +} + + + +namespace detail { + +template +struct UniqueSelector +{ + typedef UniquePtr SingleObject; +}; + +template +struct UniqueSelector +{ + typedef UniquePtr UnknownBound; +}; + +template +struct UniqueSelector +{ + typedef UniquePtr KnownBound; +}; + +} +# 676 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h" +template +typename detail::UniqueSelector::SingleObject +MakeUnique(Args&&... aArgs) +{ + return UniquePtr(new T(Forward(aArgs)...)); +} + +template +typename detail::UniqueSelector::UnknownBound +MakeUnique(decltype(sizeof(int)) aN) +{ + typedef typename RemoveExtent::Type ArrayType; + return UniquePtr(new ArrayType[aN]()); +} + +template +typename detail::UniqueSelector::KnownBound +MakeUnique(Args&&... aArgs) = delete; + +} +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleAutoArray.h" 1 + + + + + + + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArrayForwardDeclare.h" 1 +# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArrayForwardDeclare.h" +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 +# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArrayForwardDeclare.h" 2 + +template +class nsTArray; + +template +class FallibleTArray; + +template +class AutoTArray; + +template +using InfallibleTArray = nsTArray; +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Alignment.h" 1 +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Alignment.h" +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Alignment.h" 2 + + +namespace mozilla { + + + + + +template +class AlignmentFinder +{ + struct Aligner + { + char mChar; + T mT; + }; + +public: + static const size_t alignment = sizeof(Aligner) - sizeof(T); +}; +# 64 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Alignment.h" +template +struct AlignedElem; + + + + + + +template<> +struct AlignedElem<1> +{ + uint8_t elem __attribute__((aligned(1))); +}; + +template<> +struct AlignedElem<2> +{ + uint8_t elem __attribute__((aligned(2))); +}; + +template<> +struct AlignedElem<4> +{ + uint8_t elem __attribute__((aligned(4))); +}; + +template<> +struct AlignedElem<8> +{ + uint8_t elem __attribute__((aligned(8))); +}; + +template<> +struct AlignedElem<16> +{ + uint8_t elem __attribute__((aligned(16))); +}; + +template +struct AlignedStorage2 +{ + union U + { + char mBytes[sizeof(T)]; + uint64_t mDummy; + } u; + + const T* addr() const { return reinterpret_cast(u.mBytes); } + T* addr() { return static_cast(static_cast(u.mBytes)); } + + AlignedStorage2() = default; + + + + AlignedStorage2(const AlignedStorage2&) = delete; + void operator=(const AlignedStorage2&) = delete; +}; + +} +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayIterator.h" 1 +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayIterator.h" +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 1 3 +# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 3 + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 1 3 +# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 89 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 3 + struct input_iterator_tag { }; + + + struct output_iterator_tag { }; + + + struct forward_iterator_tag : public input_iterator_tag { }; + + + + struct bidirectional_iterator_tag : public forward_iterator_tag { }; + + + + struct random_access_iterator_tag : public bidirectional_iterator_tag { }; +# 116 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 3 + template + struct iterator + { + + typedef _Category iterator_category; + + typedef _Tp value_type; + + typedef _Distance difference_type; + + typedef _Pointer pointer; + + typedef _Reference reference; + }; +# 143 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 3 + template> + struct __iterator_traits { }; + + template + struct __iterator_traits<_Iterator, + __void_t> + { + typedef typename _Iterator::iterator_category iterator_category; + typedef typename _Iterator::value_type value_type; + typedef typename _Iterator::difference_type difference_type; + typedef typename _Iterator::pointer pointer; + typedef typename _Iterator::reference reference; + }; + + template + struct iterator_traits + : public __iterator_traits<_Iterator> { }; +# 177 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits<_Tp*> + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef _Tp* pointer; + typedef _Tp& reference; + }; + + + template + struct iterator_traits + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef const _Tp* pointer; + typedef const _Tp& reference; + }; + + + + + + template + inline typename iterator_traits<_Iter>::iterator_category + __iterator_category(const _Iter&) + { return typename iterator_traits<_Iter>::iterator_category(); } +# 230 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 3 + template + using _RequireInputIter = typename + enable_if::iterator_category, + input_iterator_tag>::value>::type; + + + +} +# 62 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_funcs.h" 1 3 +# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_funcs.h" 3 + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/debug/assertions.h" 1 3 +# 66 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_funcs.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template struct _List_iterator; + template struct _List_const_iterator; + + + + + template + inline typename iterator_traits<_InputIterator>::difference_type + __distance(_InputIterator __first, _InputIterator __last, + input_iterator_tag) + { + + + + typename iterator_traits<_InputIterator>::difference_type __n = 0; + while (__first != __last) + { + ++__first; + ++__n; + } + return __n; + } + + template + inline typename iterator_traits<_RandomAccessIterator>::difference_type + __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, + random_access_iterator_tag) + { + + + + return __last - __first; + } + + + + template + ptrdiff_t + __distance(std::_List_iterator<_Tp>, + std::_List_iterator<_Tp>, + input_iterator_tag); + + template + ptrdiff_t + __distance(std::_List_const_iterator<_Tp>, + std::_List_const_iterator<_Tp>, + input_iterator_tag); +# 133 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_funcs.h" 3 + template + inline typename iterator_traits<_InputIterator>::difference_type + distance(_InputIterator __first, _InputIterator __last) + { + + return std::__distance(__first, __last, + std::__iterator_category(__first)); + } + + template + inline void + __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) + { + + + ; + while (__n--) + ++__i; + } + + template + inline void + __advance(_BidirectionalIterator& __i, _Distance __n, + bidirectional_iterator_tag) + { + + + + if (__n > 0) + while (__n--) + ++__i; + else + while (__n++) + --__i; + } + + template + inline void + __advance(_RandomAccessIterator& __i, _Distance __n, + random_access_iterator_tag) + { + + + + __i += __n; + } +# 192 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_funcs.h" 3 + template + inline void + advance(_InputIterator& __i, _Distance __n) + { + + typename iterator_traits<_InputIterator>::difference_type __d = __n; + std::__advance(__i, __d, std::__iterator_category(__i)); + } + + + + template + inline _ForwardIterator + next(_ForwardIterator __x, typename + iterator_traits<_ForwardIterator>::difference_type __n = 1) + { + + + + std::advance(__x, __n); + return __x; + } + + template + inline _BidirectionalIterator + prev(_BidirectionalIterator __x, typename + iterator_traits<_BidirectionalIterator>::difference_type __n = 1) + { + + + + std::advance(__x, -__n); + return __x; + } + + + + +} +# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 1 3 +# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/cpp_type_traits.h" 1 3 +# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/cpp_type_traits.h" 3 +# 67 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/cpp_type_traits.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + struct __true_type { }; + struct __false_type { }; + + template + struct __truth_type + { typedef __false_type __type; }; + + template<> + struct __truth_type + { typedef __true_type __type; }; + + + + template + struct __traitor + { + enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; + typedef typename __truth_type<__value>::__type __type; + }; + + + template + struct __are_same + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __are_same<_Tp, _Tp> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_void + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_void + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_integer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 278 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/cpp_type_traits.h" 3 + template + struct __is_floating + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_pointer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __is_pointer<_Tp*> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_arithmetic + : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > + { }; + + + + + template + struct __is_scalar + : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > + { }; + + + + + template + struct __is_char + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_byte + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_move_iterator + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + template + inline _Iterator + __miter_base(_Iterator __it) + { return __it; } + + +} +} +# 64 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/type_traits.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/type_traits.h" 3 + + + + +extern "C++" { + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct __enable_if + { }; + + template + struct __enable_if + { typedef _Tp __type; }; + + + + template + struct __conditional_type + { typedef _Iftrue __type; }; + + template + struct __conditional_type + { typedef _Iffalse __type; }; + + + + template + struct __add_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned short __type; }; + + template<> + struct __add_unsigned + { typedef unsigned int __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long long __type; }; + + + template<> + struct __add_unsigned; + + template<> + struct __add_unsigned; + + + + template + struct __remove_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef short __type; }; + + template<> + struct __remove_unsigned + { typedef int __type; }; + + template<> + struct __remove_unsigned + { typedef long __type; }; + + template<> + struct __remove_unsigned + { typedef long long __type; }; + + + template<> + struct __remove_unsigned; + + template<> + struct __remove_unsigned; + + + + template + inline bool + __is_null_pointer(_Type* __ptr) + { return __ptr == 0; } + + template + inline bool + __is_null_pointer(_Type) + { return false; } + + + inline bool + __is_null_pointer(std::nullptr_t) + { return true; } + + + + template::__value> + struct __promote + { typedef double __type; }; + + + + + template + struct __promote<_Tp, false> + { }; + + template<> + struct __promote + { typedef long double __type; }; + + template<> + struct __promote + { typedef double __type; }; + + template<> + struct __promote + { typedef float __type; }; + + template::__type, + typename _Up2 = typename __promote<_Up>::__type> + struct __promote_2 + { + typedef __typeof__(_Tp2() + _Up2()) __type; + }; + + template::__type, + typename _Up2 = typename __promote<_Up>::__type, + typename _Vp2 = typename __promote<_Vp>::__type> + struct __promote_3 + { + typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type; + }; + + template::__type, + typename _Up2 = typename __promote<_Up>::__type, + typename _Vp2 = typename __promote<_Vp>::__type, + typename _Wp2 = typename __promote<_Wp>::__type> + struct __promote_4 + { + typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type; + }; + + +} +} +# 65 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 2 3 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ptr_traits.h" 1 3 +# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ptr_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + class __undefined; + + + template + struct __get_first_arg + { using type = __undefined; }; + + template class _Template, typename _Tp, + typename... _Types> + struct __get_first_arg<_Template<_Tp, _Types...>> + { using type = _Tp; }; + + template + using __get_first_arg_t = typename __get_first_arg<_Tp>::type; + + + template + struct __replace_first_arg + { using type = __undefined; }; + + template class _Template, typename _Up, + typename _Tp, typename... _Types> + struct __replace_first_arg<_Template<_Tp, _Types...>, _Up> + { using type = _Template<_Up, _Types...>; }; + + template + using __replace_first_arg_t = typename __replace_first_arg<_Tp, _Up>::type; + + template + using __make_not_void + = typename conditional::value, __undefined, _Tp>::type; + + + + + + template + struct pointer_traits + { + private: + template + using __element_type = typename _Tp::element_type; + + template + using __difference_type = typename _Tp::difference_type; + + template + using __rebind = typename _Tp::template rebind<_Up>; + + public: + + using pointer = _Ptr; + + + using element_type + = __detected_or_t_<__get_first_arg_t, __element_type, _Ptr>; + + + using difference_type + = __detected_or_t; + + + template + using rebind + = __detected_or_t_<__replace_first_arg_t, __rebind, _Ptr, _Up>; + + static _Ptr + pointer_to(__make_not_void& __e) + { return _Ptr::pointer_to(__e); } + + static_assert(!is_same::value, + "pointer type defines element_type or is like SomePointer"); + static_assert(!is_same, __undefined>::value, + "pointer type defines rebind or is like SomePointer"); + }; + + + + + + template + struct pointer_traits<_Tp*> + { + + typedef _Tp* pointer; + + typedef _Tp element_type; + + typedef ptrdiff_t difference_type; + + template + using rebind = _Up*; + + + + + + + static pointer + pointer_to(__make_not_void& __r) noexcept + { return std::addressof(__r); } + }; + + + template + using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>; + + +} +# 67 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 96 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3 + template + class reverse_iterator + : public iterator::iterator_category, + typename iterator_traits<_Iterator>::value_type, + typename iterator_traits<_Iterator>::difference_type, + typename iterator_traits<_Iterator>::pointer, + typename iterator_traits<_Iterator>::reference> + { + protected: + _Iterator current; + + typedef iterator_traits<_Iterator> __traits_type; + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::pointer pointer; + typedef typename __traits_type::reference reference; + + + + + + + + reverse_iterator() : current() { } + + + + + explicit + reverse_iterator(iterator_type __x) : current(__x) { } + + + + + reverse_iterator(const reverse_iterator& __x) + : current(__x.current) { } + + + + + + template + reverse_iterator(const reverse_iterator<_Iter>& __x) + : current(__x.base()) { } + + + + + iterator_type + base() const + { return current; } +# 160 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3 + reference + operator*() const + { + _Iterator __tmp = current; + return *--__tmp; + } + + + + + + + pointer + operator->() const + { return &(operator*()); } + + + + + + + reverse_iterator& + operator++() + { + --current; + return *this; + } + + + + + + + reverse_iterator + operator++(int) + { + reverse_iterator __tmp = *this; + --current; + return __tmp; + } + + + + + + + reverse_iterator& + operator--() + { + ++current; + return *this; + } + + + + + + + reverse_iterator + operator--(int) + { + reverse_iterator __tmp = *this; + ++current; + return __tmp; + } + + + + + + + reverse_iterator + operator+(difference_type __n) const + { return reverse_iterator(current - __n); } + + + + + + + + reverse_iterator& + operator+=(difference_type __n) + { + current -= __n; + return *this; + } + + + + + + + reverse_iterator + operator-(difference_type __n) const + { return reverse_iterator(current + __n); } + + + + + + + + reverse_iterator& + operator-=(difference_type __n) + { + current += __n; + return *this; + } + + + + + + + reference + operator[](difference_type __n) const + { return *(*this + __n); } + }; +# 290 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3 + template + inline bool + operator==(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } + + template + inline bool + operator<(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y.base() < __x.base(); } + + template + inline bool + operator!=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + inline bool + operator>(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y < __x; } + + template + inline bool + operator<=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + inline bool + operator>=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x < __y); } + + template + + + + + + inline auto + operator-(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + -> decltype(__x.base() - __y.base()) + + { return __y.base() - __x.base(); } + + template + inline reverse_iterator<_Iterator> + operator+(typename reverse_iterator<_Iterator>::difference_type __n, + const reverse_iterator<_Iterator>& __x) + { return reverse_iterator<_Iterator>(__x.base() - __n); } + + + + template + inline bool + operator==(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() == __y.base(); } + + template + inline bool + operator<(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __y.base() < __x.base(); } + + template + inline bool + operator!=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return !(__x == __y); } + + template + inline bool + operator>(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __y < __x; } + + template + inline bool + operator<=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return !(__y < __x); } + + template + inline bool + operator>=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return !(__x < __y); } + + template + + + inline auto + operator-(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + -> decltype(__y.base() - __x.base()) + + + + + + { return __y.base() - __x.base(); } + + + + + template + inline reverse_iterator<_Iterator> + __make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } + + + + + + + + template + inline reverse_iterator<_Iterator> + make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } + + + + + template + auto + __niter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__niter_base(__it.base()))) + { return __make_reverse_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + : __is_move_iterator<_Iterator> + { }; + + template + auto + __miter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__miter_base(__it.base()))) + { return __make_reverse_iterator(__miter_base(__it.base())); } +# 448 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3 + template + class back_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + explicit + back_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 483 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3 + back_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_back(__value); + return *this; + } + + back_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_back(std::move(__value)); + return *this; + } + + + + back_insert_iterator& + operator*() + { return *this; } + + + back_insert_iterator& + operator++() + { return *this; } + + + back_insert_iterator + operator++(int) + { return *this; } + }; +# 525 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3 + template + inline back_insert_iterator<_Container> + back_inserter(_Container& __x) + { return back_insert_iterator<_Container>(__x); } +# 540 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3 + template + class front_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + explicit front_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 574 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3 + front_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_front(__value); + return *this; + } + + front_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_front(std::move(__value)); + return *this; + } + + + + front_insert_iterator& + operator*() + { return *this; } + + + front_insert_iterator& + operator++() + { return *this; } + + + front_insert_iterator + operator++(int) + { return *this; } + }; +# 616 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3 + template + inline front_insert_iterator<_Container> + front_inserter(_Container& __x) + { return front_insert_iterator<_Container>(__x); } +# 635 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3 + template + class insert_iterator + : public iterator + { + protected: + _Container* container; + typename _Container::iterator iter; + + public: + + typedef _Container container_type; + + + + + + insert_iterator(_Container& __x, typename _Container::iterator __i) + : container(std::__addressof(__x)), iter(__i) {} +# 686 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3 + insert_iterator& + operator=(const typename _Container::value_type& __value) + { + iter = container->insert(iter, __value); + ++iter; + return *this; + } + + insert_iterator& + operator=(typename _Container::value_type&& __value) + { + iter = container->insert(iter, std::move(__value)); + ++iter; + return *this; + } + + + + insert_iterator& + operator*() + { return *this; } + + + insert_iterator& + operator++() + { return *this; } + + + insert_iterator& + operator++(int) + { return *this; } + }; +# 730 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3 + template + inline insert_iterator<_Container> + inserter(_Container& __x, _Iterator __i) + { + return insert_iterator<_Container>(__x, + typename _Container::iterator(__i)); + } + + + + +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ +# 754 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3 + using std::iterator_traits; + using std::iterator; + template + class __normal_iterator + { + protected: + _Iterator _M_current; + + typedef iterator_traits<_Iterator> __traits_type; + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; + typedef typename __traits_type::pointer pointer; + + constexpr __normal_iterator() noexcept + : _M_current(_Iterator()) { } + + explicit + __normal_iterator(const _Iterator& __i) noexcept + : _M_current(__i) { } + + + template + __normal_iterator(const __normal_iterator<_Iter, + typename __enable_if< + (std::__are_same<_Iter, typename _Container::pointer>::__value), + _Container>::__type>& __i) noexcept + : _M_current(__i.base()) { } + + + reference + operator*() const noexcept + { return *_M_current; } + + pointer + operator->() const noexcept + { return _M_current; } + + __normal_iterator& + operator++() noexcept + { + ++_M_current; + return *this; + } + + __normal_iterator + operator++(int) noexcept + { return __normal_iterator(_M_current++); } + + + __normal_iterator& + operator--() noexcept + { + --_M_current; + return *this; + } + + __normal_iterator + operator--(int) noexcept + { return __normal_iterator(_M_current--); } + + + reference + operator[](difference_type __n) const noexcept + { return _M_current[__n]; } + + __normal_iterator& + operator+=(difference_type __n) noexcept + { _M_current += __n; return *this; } + + __normal_iterator + operator+(difference_type __n) const noexcept + { return __normal_iterator(_M_current + __n); } + + __normal_iterator& + operator-=(difference_type __n) noexcept + { _M_current -= __n; return *this; } + + __normal_iterator + operator-(difference_type __n) const noexcept + { return __normal_iterator(_M_current - __n); } + + const _Iterator& + base() const noexcept + { return _M_current; } + }; +# 854 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3 + template + inline bool + operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + inline bool + operator==(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + inline bool + operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + template + inline bool + operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + + template + inline bool + operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + inline bool + operator<(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + inline bool + operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + inline bool + operator>(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + inline bool + operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + inline bool + operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + inline bool + operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + template + inline bool + operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + + + + + template + + + inline auto + operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept + -> decltype(__lhs.base() - __rhs.base()) + + + + + + { return __lhs.base() - __rhs.base(); } + + template + inline typename __normal_iterator<_Iterator, _Container>::difference_type + operator-(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() - __rhs.base(); } + + template + inline __normal_iterator<_Iterator, _Container> + operator+(typename __normal_iterator<_Iterator, _Container>::difference_type + __n, const __normal_iterator<_Iterator, _Container>& __i) + noexcept + { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } + + +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + _Iterator + __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) + { return __it.base(); } + + +} + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 1006 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3 + template + class move_iterator + { + protected: + _Iterator _M_current; + + typedef iterator_traits<_Iterator> __traits_type; + typedef typename __traits_type::reference __base_ref; + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + + typedef _Iterator pointer; + + + typedef typename conditional::value, + typename remove_reference<__base_ref>::type&&, + __base_ref>::type reference; + + move_iterator() + : _M_current() { } + + explicit + move_iterator(iterator_type __i) + : _M_current(__i) { } + + template + move_iterator(const move_iterator<_Iter>& __i) + : _M_current(__i.base()) { } + + iterator_type + base() const + { return _M_current; } + + reference + operator*() const + { return static_cast(*_M_current); } + + pointer + operator->() const + { return _M_current; } + + move_iterator& + operator++() + { + ++_M_current; + return *this; + } + + move_iterator + operator++(int) + { + move_iterator __tmp = *this; + ++_M_current; + return __tmp; + } + + move_iterator& + operator--() + { + --_M_current; + return *this; + } + + move_iterator + operator--(int) + { + move_iterator __tmp = *this; + --_M_current; + return __tmp; + } + + move_iterator + operator+(difference_type __n) const + { return move_iterator(_M_current + __n); } + + move_iterator& + operator+=(difference_type __n) + { + _M_current += __n; + return *this; + } + + move_iterator + operator-(difference_type __n) const + { return move_iterator(_M_current - __n); } + + move_iterator& + operator-=(difference_type __n) + { + _M_current -= __n; + return *this; + } + + reference + operator[](difference_type __n) const + { return std::move(_M_current[__n]); } + }; + + + + + template + inline bool + operator==(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return __x.base() == __y.base(); } + + template + inline bool + operator==(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } + + template + inline bool + operator!=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return !(__x == __y); } + + template + inline bool + operator!=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + inline bool + operator<(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return __x.base() < __y.base(); } + + template + inline bool + operator<(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() < __y.base(); } + + template + inline bool + operator<=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return !(__y < __x); } + + template + inline bool + operator<=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + inline bool + operator>(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return __y < __x; } + + template + inline bool + operator>(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __y < __x; } + + template + inline bool + operator>=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return !(__x < __y); } + + template + inline bool + operator>=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + template + inline auto + operator-(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + -> decltype(__x.base() - __y.base()) + { return __x.base() - __y.base(); } + + template + inline auto + operator-(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + -> decltype(__x.base() - __y.base()) + { return __x.base() - __y.base(); } + + template + inline move_iterator<_Iterator> + operator+(typename move_iterator<_Iterator>::difference_type __n, + const move_iterator<_Iterator>& __x) + { return __x + __n; } + + template + inline move_iterator<_Iterator> + make_move_iterator(_Iterator __i) + { return move_iterator<_Iterator>(__i); } + + template::value_type>::value, + _Iterator, move_iterator<_Iterator>>::type> + inline _ReturnType + __make_move_if_noexcept_iterator(_Iterator __i) + { return _ReturnType(__i); } + + + + template::value, + const _Tp*, move_iterator<_Tp*>>::type> + inline _ReturnType + __make_move_if_noexcept_iterator(_Tp* __i) + { return _ReturnType(__i); } + + + + template + auto + __niter_base(move_iterator<_Iterator> __it) + -> decltype(make_move_iterator(__niter_base(__it.base()))) + { return make_move_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template + auto + __miter_base(move_iterator<_Iterator> __it) + -> decltype(__miter_base(__it.base())) + { return __miter_base(__it.base()); } + + +} +# 64 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 1 3 +# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 1 3 +# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 3 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iosfwd" 1 3 +# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iosfwd" 3 + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stringfwd.h" 1 3 +# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stringfwd.h" 3 + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/memoryfwd.h" 1 3 +# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/memoryfwd.h" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/memoryfwd.h" 3 + template + class allocator; + + template<> + class allocator; + + + template + struct uses_allocator; + + + + +} +# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stringfwd.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 52 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stringfwd.h" 3 + template + struct char_traits; + + template<> struct char_traits; + + + template<> struct char_traits; + + + + + template<> struct char_traits; + template<> struct char_traits; + + +namespace __cxx11 { + + template, + typename _Alloc = allocator<_CharT> > + class basic_string; + + + typedef basic_string string; + + + + typedef basic_string wstring; + + + + + + typedef basic_string u16string; + + + typedef basic_string u32string; + + +} + + + + +} +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iosfwd" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 1 3 +# 39 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 3 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3 + + + + +# 1 "/usr/include/wchar.h" 1 3 4 +# 45 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 2 3 +# 62 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3 +namespace std +{ + using ::mbstate_t; +} +# 135 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::wint_t; + + using ::btowc; + using ::fgetwc; + using ::fgetws; + using ::fputwc; + using ::fputws; + using ::fwide; + using ::fwprintf; + using ::fwscanf; + using ::getwc; + using ::getwchar; + using ::mbrlen; + using ::mbrtowc; + using ::mbsinit; + using ::mbsrtowcs; + using ::putwc; + using ::putwchar; + + using ::swprintf; + + using ::swscanf; + using ::ungetwc; + using ::vfwprintf; + + using ::vfwscanf; + + + using ::vswprintf; + + + using ::vswscanf; + + using ::vwprintf; + + using ::vwscanf; + + using ::wcrtomb; + using ::wcscat; + using ::wcscmp; + using ::wcscoll; + using ::wcscpy; + using ::wcscspn; + using ::wcsftime; + using ::wcslen; + using ::wcsncat; + using ::wcsncmp; + using ::wcsncpy; + using ::wcsrtombs; + using ::wcsspn; + using ::wcstod; + + using ::wcstof; + + using ::wcstok; + using ::wcstol; + using ::wcstoul; + using ::wcsxfrm; + using ::wctob; + using ::wmemcmp; + using ::wmemcpy; + using ::wmemmove; + using ::wmemset; + using ::wprintf; + using ::wscanf; + using ::wcschr; + using ::wcspbrk; + using ::wcsrchr; + using ::wcsstr; + using ::wmemchr; + + + inline wchar_t* + wcschr(wchar_t* __p, wchar_t __c) + { return wcschr(const_cast(__p), __c); } + + inline wchar_t* + wcspbrk(wchar_t* __s1, const wchar_t* __s2) + { return wcspbrk(const_cast(__s1), __s2); } + + inline wchar_t* + wcsrchr(wchar_t* __p, wchar_t __c) + { return wcsrchr(const_cast(__p), __c); } + + inline wchar_t* + wcsstr(wchar_t* __s1, const wchar_t* __s2) + { return wcsstr(const_cast(__s1), __s2); } + + inline wchar_t* + wmemchr(wchar_t* __p, wchar_t __c, size_t __n) + { return wmemchr(const_cast(__p), __c, __n); } + + + +} + + + + + + + +namespace __gnu_cxx +{ + + + + + + using ::wcstold; +# 257 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3 + using ::wcstoll; + using ::wcstoull; + +} + +namespace std +{ + using ::__gnu_cxx::wcstold; + using ::__gnu_cxx::wcstoll; + using ::__gnu_cxx::wcstoull; +} +# 277 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3 +namespace std +{ + + using std::wcstof; + + + using std::vfwscanf; + + + using std::vswscanf; + + + using std::vwscanf; + + + + using std::wcstold; + using std::wcstoll; + using std::wcstoull; + +} +# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 2 3 +# 68 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 88 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 3 + typedef long streamoff; +# 98 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 3 + typedef ptrdiff_t streamsize; +# 111 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 3 + template + class fpos + { + private: + streamoff _M_off; + _StateT _M_state; + + public: + + + + + fpos() + : _M_off(0), _M_state() { } +# 133 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 3 + fpos(streamoff __off) + : _M_off(__off), _M_state() { } + + + operator streamoff() const { return _M_off; } + + + void + state(_StateT __st) + { _M_state = __st; } + + + _StateT + state() const + { return _M_state; } + + + + + + fpos& + operator+=(streamoff __off) + { + _M_off += __off; + return *this; + } + + + + + + fpos& + operator-=(streamoff __off) + { + _M_off -= __off; + return *this; + } + + + + + + + + fpos + operator+(streamoff __off) const + { + fpos __pos(*this); + __pos += __off; + return __pos; + } + + + + + + + + fpos + operator-(streamoff __off) const + { + fpos __pos(*this); + __pos -= __off; + return __pos; + } + + + + + + + streamoff + operator-(const fpos& __other) const + { return _M_off - __other._M_off; } + }; + + + + + + + template + inline bool + operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) + { return streamoff(__lhs) == streamoff(__rhs); } + + template + inline bool + operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) + { return streamoff(__lhs) != streamoff(__rhs); } + + + + + + typedef fpos streampos; + + typedef fpos wstreampos; + + + + typedef fpos u16streampos; + + typedef fpos u32streampos; + + + +} +# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iosfwd" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 74 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iosfwd" 3 + class ios_base; + + template > + class basic_ios; + + template > + class basic_streambuf; + + template > + class basic_istream; + + template > + class basic_ostream; + + template > + class basic_iostream; + + +namespace __cxx11 { + + template, + typename _Alloc = allocator<_CharT> > + class basic_stringbuf; + + template, + typename _Alloc = allocator<_CharT> > + class basic_istringstream; + + template, + typename _Alloc = allocator<_CharT> > + class basic_ostringstream; + + template, + typename _Alloc = allocator<_CharT> > + class basic_stringstream; + +} + + template > + class basic_filebuf; + + template > + class basic_ifstream; + + template > + class basic_ofstream; + + template > + class basic_fstream; + + template > + class istreambuf_iterator; + + template > + class ostreambuf_iterator; + + + + typedef basic_ios ios; + + + typedef basic_streambuf streambuf; + + + typedef basic_istream istream; + + + typedef basic_ostream ostream; + + + typedef basic_iostream iostream; + + + typedef basic_stringbuf stringbuf; + + + typedef basic_istringstream istringstream; + + + typedef basic_ostringstream ostringstream; + + + typedef basic_stringstream stringstream; + + + typedef basic_filebuf filebuf; + + + typedef basic_ifstream ifstream; + + + typedef basic_ofstream ofstream; + + + typedef basic_fstream fstream; + + + + typedef basic_ios wios; + + + typedef basic_streambuf wstreambuf; + + + typedef basic_istream wistream; + + + typedef basic_ostream wostream; + + + typedef basic_iostream wiostream; + + + typedef basic_stringbuf wstringbuf; + + + typedef basic_istringstream wistringstream; + + + typedef basic_ostringstream wostringstream; + + + typedef basic_stringstream wstringstream; + + + typedef basic_filebuf wfilebuf; + + + typedef basic_ifstream wifstream; + + + typedef basic_ofstream wofstream; + + + typedef basic_fstream wfstream; + + + + +} +# 39 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 2 3 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 1 3 +# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 3 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 1 3 +# 60 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functexcept.h" 1 3 +# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functexcept.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + void + __throw_bad_exception(void) __attribute__((__noreturn__)); + + + void + __throw_bad_alloc(void) __attribute__((__noreturn__)); + + + void + __throw_bad_cast(void) __attribute__((__noreturn__)); + + void + __throw_bad_typeid(void) __attribute__((__noreturn__)); + + + void + __throw_logic_error(const char*) __attribute__((__noreturn__)); + + void + __throw_domain_error(const char*) __attribute__((__noreturn__)); + + void + __throw_invalid_argument(const char*) __attribute__((__noreturn__)); + + void + __throw_length_error(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__)) + __attribute__((__format__(__gnu_printf__, 1, 2))); + + void + __throw_runtime_error(const char*) __attribute__((__noreturn__)); + + void + __throw_range_error(const char*) __attribute__((__noreturn__)); + + void + __throw_overflow_error(const char*) __attribute__((__noreturn__)); + + void + __throw_underflow_error(const char*) __attribute__((__noreturn__)); + + + void + __throw_ios_failure(const char*) __attribute__((__noreturn__)); + + void + __throw_system_error(int) __attribute__((__noreturn__)); + + void + __throw_future_error(int) __attribute__((__noreturn__)); + + + void + __throw_bad_function_call() __attribute__((__noreturn__)); + + +} +# 61 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/numeric_traits.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/numeric_traits.h" 3 + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ +# 54 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/numeric_traits.h" 3 + template + struct __numeric_traits_integer + { + + static const _Value __min = (((_Value)(-1) < 0) ? (_Value)1 << (sizeof(_Value) * 8 - ((_Value)(-1) < 0)) : (_Value)0); + static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0); + + + + static const bool __is_signed = ((_Value)(-1) < 0); + static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0)); + }; + + template + const _Value __numeric_traits_integer<_Value>::__min; + + template + const _Value __numeric_traits_integer<_Value>::__max; + + template + const bool __numeric_traits_integer<_Value>::__is_signed; + + template + const int __numeric_traits_integer<_Value>::__digits; +# 99 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/numeric_traits.h" 3 + template + struct __numeric_traits_floating + { + + static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136); + + + static const bool __is_signed = true; + static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18); + static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932); + }; + + template + const int __numeric_traits_floating<_Value>::__max_digits10; + + template + const bool __numeric_traits_floating<_Value>::__is_signed; + + template + const int __numeric_traits_floating<_Value>::__digits10; + + template + const int __numeric_traits_floating<_Value>::__max_exponent10; + + template + struct __numeric_traits + : public __conditional_type::__value, + __numeric_traits_integer<_Value>, + __numeric_traits_floating<_Value> >::__type + { }; + + +} +# 64 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 1 3 +# 65 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 76 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3 + struct piecewise_construct_t { explicit piecewise_construct_t() = default; }; + + + constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t(); + + + template + class tuple; + + template + struct _Index_tuple; + + + + + + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return __and_, + is_constructible<_T2, const _U2&>>::value; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return __and_, + is_convertible>::value; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return __and_, + is_constructible<_T2, _U2&&>>::value; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return __and_, + is_convertible<_U2&&, _T2>>::value; + } + + template + static constexpr bool _CopyMovePair() + { + using __do_converts = __and_, + is_convertible<_U2&&, _T2>>; + using __converts = typename conditional<__implicit, + __do_converts, + __not_<__do_converts>>::type; + return __and_, + is_constructible<_T2, _U2&&>, + __converts + >::value; + } + + template + static constexpr bool _MoveCopyPair() + { + using __do_converts = __and_, + is_convertible>; + using __converts = typename conditional<__implicit, + __do_converts, + __not_<__do_converts>>::type; + return __and_, + is_constructible<_T2, const _U2&&>, + __converts + >::value; + } + }; + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return false; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return false; + } + }; +# 189 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3 + template + struct pair + { + typedef _T1 first_type; + typedef _T2 second_type; + + _T1 first; + _T2 second; + + + + + + + template , + __is_implicitly_default_constructible<_U2>> + ::value, bool>::type = true> + + constexpr pair() + : first(), second() { } + + + template , + is_default_constructible<_U2>, + __not_< + __and_<__is_implicitly_default_constructible<_U1>, + __is_implicitly_default_constructible<_U2>>>> + ::value, bool>::type = false> + explicit constexpr pair() + : first(), second() { } +# 233 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3 + using _PCCP = _PCC; + + template() + && _PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + template() + && !_PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } +# 261 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3 + template + using _PCCFP = _PCC::value + || !is_same<_T2, _U2>::value, + _T1, _T2>; + + template::template + _ConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) { } + + template::template + _ConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) { } + + constexpr pair(const pair&) = default; + constexpr pair(pair&&) = default; + + + template(), + bool>::type=true> + constexpr pair(_U1&& __x, const _T2& __y) + : first(std::forward<_U1>(__x)), second(__y) { } + + template(), + bool>::type=false> + explicit constexpr pair(_U1&& __x, const _T2& __y) + : first(std::forward<_U1>(__x)), second(__y) { } + + template(), + bool>::type=true> + constexpr pair(const _T1& __x, _U2&& __y) + : first(__x), second(std::forward<_U2>(__y)) { } + + template(), + bool>::type=false> + explicit pair(const _T1& __x, _U2&& __y) + : first(__x), second(std::forward<_U2>(__y)) { } + + template() + && _PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { } + + template() + && !_PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { } + + + template::template + _MoveConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) { } + + template::template + _MoveConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) { } + + template + pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); + + pair& + operator=(typename conditional< + __and_, + is_copy_assignable<_T2>>::value, + const pair&, const __nonesuch&>::type __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + pair& + operator=(typename conditional< + __not_<__and_, + is_copy_assignable<_T2>>>::value, + const pair&, const __nonesuch&>::type __p) = delete; + + pair& + operator=(typename conditional< + __and_, + is_move_assignable<_T2>>::value, + pair&&, __nonesuch&&>::type __p) + noexcept(__and_, + is_nothrow_move_assignable<_T2>>::value) + { + first = std::forward(__p.first); + second = std::forward(__p.second); + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, const _U2&>>::value, + pair&>::type + operator=(const pair<_U1, _U2>& __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, _U2&&>>::value, + pair&>::type + operator=(pair<_U1, _U2>&& __p) + { + first = std::forward<_U1>(__p.first); + second = std::forward<_U2>(__p.second); + return *this; + } + + void + swap(pair& __p) + noexcept(__is_nothrow_swappable<_T1>::value + && __is_nothrow_swappable<_T2>::value) + { + using std::swap; + swap(first, __p.first); + swap(second, __p.second); + } + + private: + template + pair(tuple<_Args1...>&, tuple<_Args2...>&, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); + + }; + + + template + inline constexpr bool + operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first == __y.first && __x.second == __y.second; } + + + template + inline constexpr bool + operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first < __y.first + || (!(__y.first < __x.first) && __x.second < __y.second); } + + + template + inline constexpr bool + operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x == __y); } + + + template + inline constexpr bool + operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __y < __x; } + + + template + inline constexpr bool + operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__y < __x); } + + + template + inline constexpr bool + operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x < __y); } + + + + + + template + inline void + swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } +# 490 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3 + template + constexpr pair::__type, + typename __decay_and_strip<_T2>::__type> + make_pair(_T1&& __x, _T2&& __y) + { + typedef typename __decay_and_strip<_T1>::__type __ds_type1; + typedef typename __decay_and_strip<_T2>::__type __ds_type2; + typedef pair<__ds_type1, __ds_type2> __pair_type; + return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y)); + } +# 510 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3 +} +# 65 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 2 3 + + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/debug/debug.h" 1 3 +# 48 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/debug/debug.h" 3 +namespace std +{ + namespace __debug { } +} + + + + +namespace __gnu_debug +{ + using namespace std::__debug; +} +# 70 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 2 3 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/predefined_ops.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/predefined_ops.h" 3 +namespace __gnu_cxx +{ +namespace __ops +{ + struct _Iter_less_iter + { + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 < *__it2; } + }; + constexpr + inline _Iter_less_iter + __iter_less_iter() + { return _Iter_less_iter(); } + + struct _Iter_less_val + { + template + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it < __val; } + }; + + inline _Iter_less_val + __iter_less_val() + { return _Iter_less_val(); } + + inline _Iter_less_val + __iter_comp_val(_Iter_less_iter) + { return _Iter_less_val(); } + + struct _Val_less_iter + { + template + bool + operator()(_Value& __val, _Iterator __it) const + { return __val < *__it; } + }; + + inline _Val_less_iter + __val_less_iter() + { return _Val_less_iter(); } + + inline _Val_less_iter + __val_comp_iter(_Iter_less_iter) + { return _Val_less_iter(); } + + struct _Iter_equal_to_iter + { + template + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 == *__it2; } + }; + + inline _Iter_equal_to_iter + __iter_equal_to_iter() + { return _Iter_equal_to_iter(); } + + struct _Iter_equal_to_val + { + template + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it == __val; } + }; + + inline _Iter_equal_to_val + __iter_equal_to_val() + { return _Iter_equal_to_val(); } + + inline _Iter_equal_to_val + __iter_comp_val(_Iter_equal_to_iter) + { return _Iter_equal_to_val(); } + + template + struct _Iter_comp_iter + { + _Compare _M_comp; + constexpr + _Iter_comp_iter(_Compare __comp) + : _M_comp(__comp) + { } + + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) + { return bool(_M_comp(*__it1, *__it2)); } + }; + + template + constexpr + inline _Iter_comp_iter<_Compare> + __iter_comp_iter(_Compare __comp) + { return _Iter_comp_iter<_Compare>(__comp); } + + template + struct _Iter_comp_val + { + _Compare _M_comp; + + _Iter_comp_val(_Compare __comp) + : _M_comp(__comp) + { } + + template + bool + operator()(_Iterator __it, _Value& __val) + { return bool(_M_comp(*__it, __val)); } + }; + + template + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Compare __comp) + { return _Iter_comp_val<_Compare>(__comp); } + + template + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Iter_comp_iter<_Compare> __comp) + { return _Iter_comp_val<_Compare>(__comp._M_comp); } + + template + struct _Val_comp_iter + { + _Compare _M_comp; + + _Val_comp_iter(_Compare __comp) + : _M_comp(__comp) + { } + + template + bool + operator()(_Value& __val, _Iterator __it) + { return bool(_M_comp(__val, *__it)); } + }; + + template + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Compare __comp) + { return _Val_comp_iter<_Compare>(__comp); } + + template + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Iter_comp_iter<_Compare> __comp) + { return _Val_comp_iter<_Compare>(__comp._M_comp); } + + template + struct _Iter_equals_val + { + _Value& _M_value; + + _Iter_equals_val(_Value& __value) + : _M_value(__value) + { } + + template + bool + operator()(_Iterator __it) + { return *__it == _M_value; } + }; + + template + inline _Iter_equals_val<_Value> + __iter_equals_val(_Value& __val) + { return _Iter_equals_val<_Value>(__val); } + + template + struct _Iter_equals_iter + { + typename std::iterator_traits<_Iterator1>::reference _M_ref; + + _Iter_equals_iter(_Iterator1 __it1) + : _M_ref(*__it1) + { } + + template + bool + operator()(_Iterator2 __it2) + { return *__it2 == _M_ref; } + }; + + template + inline _Iter_equals_iter<_Iterator> + __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) + { return _Iter_equals_iter<_Iterator>(__it); } + + template + struct _Iter_pred + { + _Predicate _M_pred; + + _Iter_pred(_Predicate __pred) + : _M_pred(__pred) + { } + + template + bool + operator()(_Iterator __it) + { return bool(_M_pred(*__it)); } + }; + + template + inline _Iter_pred<_Predicate> + __pred_iter(_Predicate __pred) + { return _Iter_pred<_Predicate>(__pred); } + + template + struct _Iter_comp_to_val + { + _Compare _M_comp; + _Value& _M_value; + + _Iter_comp_to_val(_Compare __comp, _Value& __value) + : _M_comp(__comp), _M_value(__value) + { } + + template + bool + operator()(_Iterator __it) + { return bool(_M_comp(*__it, _M_value)); } + }; + + template + _Iter_comp_to_val<_Compare, _Value> + __iter_comp_val(_Compare __comp, _Value &__val) + { return _Iter_comp_to_val<_Compare, _Value>(__comp, __val); } + + template + struct _Iter_comp_to_iter + { + _Compare _M_comp; + typename std::iterator_traits<_Iterator1>::reference _M_ref; + + _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) + : _M_comp(__comp), _M_ref(*__it1) + { } + + template + bool + operator()(_Iterator2 __it2) + { return bool(_M_comp(*__it2, _M_ref)); } + }; + + template + inline _Iter_comp_to_iter<_Compare, _Iterator> + __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) + { return _Iter_comp_to_iter<_Compare, _Iterator>(__comp._M_comp, __it); } + + template + struct _Iter_negate + { + _Predicate _M_pred; + + _Iter_negate(_Predicate __pred) + : _M_pred(__pred) + { } + + template + bool + operator()(_Iterator __it) + { return !bool(_M_pred(*__it)); } + }; + + template + inline _Iter_negate<_Predicate> + __negate(_Iter_pred<_Predicate> __pred) + { return _Iter_negate<_Predicate>(__pred._M_pred); } + +} +} +# 72 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 118 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + inline void + iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) + { +# 148 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + swap(*__a, *__b); + + } +# 164 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + _ForwardIterator2 + swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + std::iter_swap(__first1, __first2); + return __first2; + } +# 192 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b) + { + + + + if (__b < __a) + return __b; + return __a; + } +# 216 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b) + { + + + + if (__a < __b) + return __b; + return __a; + } +# 240 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__b, __a)) + return __b; + return __a; + } +# 262 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__a, __b)) + return __b; + return __a; + } + + + + template + inline _Iterator + __niter_base(_Iterator __it) + { return __it; } + + + + + + + + template + struct __copy_move + { + template + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = *__first; + return __result; + } + }; + + + template + struct __copy_move + { + template + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = std::move(*__first); + return __result; + } + }; + + + template<> + struct __copy_move + { + template + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = *__first; + ++__first; + ++__result; + } + return __result; + } + }; + + + template<> + struct __copy_move + { + template + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = std::move(*__first); + ++__first; + ++__result; + } + return __result; + } + }; + + + template + struct __copy_move<_IsMove, true, random_access_iterator_tag> + { + template + static _Tp* + __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result) + { + + using __assignable = conditional<_IsMove, + is_move_assignable<_Tp>, + is_copy_assignable<_Tp>>; + + static_assert( __assignable::type::value, "type is not assignable" ); + + const ptrdiff_t _Num = __last - __first; + if (_Num) + __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); + return __result + _Num; + } + }; + + template + inline _OI + __copy_move_a(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::value_type _ValueTypeI; + typedef typename iterator_traits<_OI>::value_type _ValueTypeO; + typedef typename iterator_traits<_II>::iterator_category _Category; + const bool __simple = (__is_trivial(_ValueTypeI) + && __is_pointer<_II>::__value + && __is_pointer<_OI>::__value + && __are_same<_ValueTypeI, _ValueTypeO>::__value); + + return std::__copy_move<_IsMove, __simple, + _Category>::__copy_m(__first, __last, __result); + } + + + + template + struct char_traits; + + template + class istreambuf_iterator; + + template + class ostreambuf_iterator; + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(_CharT*, _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(const _CharT*, const _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + _CharT*>::__type + __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); + + template + inline _OI + __copy_move_a2(_II __first, _II __last, _OI __result) + { + return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first), + std::__niter_base(__last), + std::__niter_base(__result))); + } +# 444 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + inline _OI + copy(_II __first, _II __last, _OI __result) + { + + + + + ; + + return (std::__copy_move_a2<__is_move_iterator<_II>::__value> + (std::__miter_base(__first), std::__miter_base(__last), + __result)); + } +# 477 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + inline _OI + move(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a2(std::__miter_base(__first), + std::__miter_base(__last), __result); + } + + + + + + + template + struct __copy_move_backward + { + template + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = *--__last; + return __result; + } + }; + + + template + struct __copy_move_backward + { + template + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type __n; + for (__n = __last - __first; __n > 0; --__n) + *--__result = *--__last; + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type __n; + for (__n = __last - __first; __n > 0; --__n) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template + struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> + { + template + static _Tp* + __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result) + { + + using __assignable = conditional<_IsMove, + is_move_assignable<_Tp>, + is_copy_assignable<_Tp>>; + + static_assert( __assignable::type::value, "type is not assignable" ); + + const ptrdiff_t _Num = __last - __first; + if (_Num) + __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); + return __result - _Num; + } + }; + + template + inline _BI2 + __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result) + { + typedef typename iterator_traits<_BI1>::value_type _ValueType1; + typedef typename iterator_traits<_BI2>::value_type _ValueType2; + typedef typename iterator_traits<_BI1>::iterator_category _Category; + const bool __simple = (__is_trivial(_ValueType1) + && __is_pointer<_BI1>::__value + && __is_pointer<_BI2>::__value + && __are_same<_ValueType1, _ValueType2>::__value); + + return std::__copy_move_backward<_IsMove, __simple, + _Category>::__copy_move_b(__first, + __last, + __result); + } + + template + inline _BI2 + __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) + { + return _BI2(std::__copy_move_backward_a<_IsMove> + (std::__niter_base(__first), std::__niter_base(__last), + std::__niter_base(__result))); + } +# 620 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + inline _BI2 + copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + + ; + + return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value> + (std::__miter_base(__first), std::__miter_base(__last), + __result)); + } +# 656 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + inline _BI2 + move_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + + ; + + return std::__copy_move_backward_a2(std::__miter_base(__first), + std::__miter_base(__last), + __result); + } + + + + + + + template + inline typename + __gnu_cxx::__enable_if::__value, void>::__type + __fill_a(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + for (; __first != __last; ++__first) + *__first = __value; + } + + template + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type + __fill_a(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __first != __last; ++__first) + *__first = __tmp; + } + + + template + inline typename + __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type + __fill_a(_Tp* __first, _Tp* __last, const _Tp& __c) + { + const _Tp __tmp = __c; + if (const size_t __len = __last - __first) + __builtin_memset(__first, static_cast(__tmp), __len); + } +# 722 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + inline void + fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) + { + + + + ; + + std::__fill_a(std::__niter_base(__first), std::__niter_base(__last), + __value); + } + + template + inline typename + __gnu_cxx::__enable_if::__value, _OutputIterator>::__type + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value) + { + for (__decltype(__n + 0) __niter = __n; + __niter > 0; --__niter, ++__first) + *__first = __value; + return __first; + } + + template + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value) + { + const _Tp __tmp = __value; + for (__decltype(__n + 0) __niter = __n; + __niter > 0; --__niter, ++__first) + *__first = __tmp; + return __first; + } + + template + inline typename + __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type + __fill_n_a(_Tp* __first, _Size __n, const _Tp& __c) + { + std::__fill_a(__first, __first + __n, __c); + return __first + __n; + } +# 782 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + inline _OI + fill_n(_OI __first, _Size __n, const _Tp& __value) + { + + + + return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value)); + } + + template + struct __equal + { + template + static bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!(*__first1 == *__first2)) + return false; + return true; + } + }; + + template<> + struct __equal + { + template + static bool + equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) + { + if (const size_t __len = (__last1 - __first1)) + return !__builtin_memcmp(__first1, __first2, sizeof(_Tp) * __len); + return true; + } + }; + + template + inline bool + __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + typedef typename iterator_traits<_II2>::value_type _ValueType2; + const bool __simple = ((__is_integer<_ValueType1>::__value + || __is_pointer<_ValueType1>::__value) + && __is_pointer<_II1>::__value + && __is_pointer<_II2>::__value + && __are_same<_ValueType1, _ValueType2>::__value); + + return std::__equal<__simple>::equal(__first1, __last1, __first2); + } + + template + struct __lc_rai + { + template + static _II1 + __newlast1(_II1, _II1 __last1, _II2, _II2) + { return __last1; } + + template + static bool + __cnd2(_II __first, _II __last) + { return __first != __last; } + }; + + template<> + struct __lc_rai + { + template + static _RAI1 + __newlast1(_RAI1 __first1, _RAI1 __last1, + _RAI2 __first2, _RAI2 __last2) + { + const typename iterator_traits<_RAI1>::difference_type + __diff1 = __last1 - __first1; + const typename iterator_traits<_RAI2>::difference_type + __diff2 = __last2 - __first2; + return __diff2 < __diff1 ? __first1 + __diff2 : __last1; + } + + template + static bool + __cnd2(_RAI, _RAI) + { return true; } + }; + + template + bool + __lexicographical_compare_impl(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, + _Compare __comp) + { + typedef typename iterator_traits<_II1>::iterator_category _Category1; + typedef typename iterator_traits<_II2>::iterator_category _Category2; + typedef std::__lc_rai<_Category1, _Category2> __rai_type; + + __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); + for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); + ++__first1, (void)++__first2) + { + if (__comp(__first1, __first2)) + return true; + if (__comp(__first2, __first1)) + return false; + } + return __first1 == __last1 && __first2 != __last2; + } + + template + struct __lexicographical_compare + { + template + static bool __lc(_II1, _II1, _II2, _II2); + }; + + template + template + bool + __lexicographical_compare<_BoolType>:: + __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + return std::__lexicographical_compare_impl(__first1, __last1, + __first2, __last2, + __gnu_cxx::__ops::__iter_less_iter()); + } + + template<> + struct __lexicographical_compare + { + template + static bool + __lc(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { + const size_t __len1 = __last1 - __first1; + const size_t __len2 = __last2 - __first2; + if (const size_t __len = std::min(__len1, __len2)) + if (int __result = __builtin_memcmp(__first1, __first2, __len)) + return __result < 0; + return __len1 < __len2; + } + }; + + template + inline bool + __lexicographical_compare_aux(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + typedef typename iterator_traits<_II2>::value_type _ValueType2; + const bool __simple = + (__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value + && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed + && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed + && __is_pointer<_II1>::__value + && __is_pointer<_II2>::__value); + + return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, + __first2, __last2); + } + + template + _ForwardIterator + __lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len = std::distance(__first, __last); + + while (__len > 0) + { + _DistanceType __half = __len >> 1; + _ForwardIterator __middle = __first; + std::advance(__middle, __half); + if (__comp(__middle, __val)) + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + else + __len = __half; + } + return __first; + } +# 982 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + inline _ForwardIterator + lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + + + + + ; + + return std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val()); + } + + + + inline constexpr int + __lg(int __n) + { return sizeof(int) * 8 - 1 - __builtin_clz(__n); } + + inline constexpr unsigned + __lg(unsigned __n) + { return sizeof(int) * 8 - 1 - __builtin_clz(__n); } + + inline constexpr long + __lg(long __n) + { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); } + + inline constexpr unsigned long + __lg(unsigned long __n) + { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); } + + inline constexpr long long + __lg(long long __n) + { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); } + + inline constexpr unsigned long long + __lg(unsigned long long __n) + { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); } +# 1039 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + + + + + + + ; + + return std::__equal_aux(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2)); + } +# 1071 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return true; + } +# 1104 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + + + + + + + ; + ; + + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if (_RAIters()) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + return std::equal(__first1, __last1, __first2); + } + + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!(*__first1 == *__first2)) + return false; + return __first1 == __last1 && __first2 == __last2; + } +# 1153 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) + { + + + + ; + ; + + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_IIter1>::iterator_category; + using _Cat2 = typename iterator_traits<_IIter2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if (_RAIters()) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + return std::equal(__first1, __last1, __first2, + __binary_pred); + } + + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return __first1 == __last1 && __first2 == __last2; + } +# 1201 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { +# 1215 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + ; + ; + + return std::__lexicographical_compare_aux(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2), + std::__niter_base(__last2)); + } +# 1237 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, _Compare __comp) + { + + + + ; + ; + + return std::__lexicographical_compare_impl + (__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 1280 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2) + { + + + + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 1313 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + template + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __first2 != __last2 + && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 1360 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2) + { + + + + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 1395 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3 + template + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + +} +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 2 3 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3 + + + + +# 1 "/usr/include/wchar.h" 1 3 4 +# 45 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 2 3 +# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 2 3 + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ +# 57 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 3 + template + struct _Char_types + { + typedef unsigned long int_type; + typedef std::streampos pos_type; + typedef std::streamoff off_type; + typedef std::mbstate_t state_type; + }; +# 82 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 3 + template + struct char_traits + { + typedef _CharT char_type; + typedef typename _Char_types<_CharT>::int_type int_type; + typedef typename _Char_types<_CharT>::pos_type pos_type; + typedef typename _Char_types<_CharT>::off_type off_type; + typedef typename _Char_types<_CharT>::state_type state_type; + + static void + assign(char_type& __c1, const char_type& __c2) + { __c1 = __c2; } + + static constexpr bool + eq(const char_type& __c1, const char_type& __c2) + { return __c1 == __c2; } + + static constexpr bool + lt(const char_type& __c1, const char_type& __c2) + { return __c1 < __c2; } + + static int + compare(const char_type* __s1, const char_type* __s2, std::size_t __n); + + static std::size_t + length(const char_type* __s); + + static const char_type* + find(const char_type* __s, std::size_t __n, const char_type& __a); + + static char_type* + move(char_type* __s1, const char_type* __s2, std::size_t __n); + + static char_type* + copy(char_type* __s1, const char_type* __s2, std::size_t __n); + + static char_type* + assign(char_type* __s, std::size_t __n, char_type __a); + + static constexpr char_type + to_char_type(const int_type& __c) + { return static_cast(__c); } + + static constexpr int_type + to_int_type(const char_type& __c) + { return static_cast(__c); } + + static constexpr bool + eq_int_type(const int_type& __c1, const int_type& __c2) + { return __c1 == __c2; } + + static constexpr int_type + eof() + { return static_cast(-1); } + + static constexpr int_type + not_eof(const int_type& __c) + { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); } + }; + + template + int + char_traits<_CharT>:: + compare(const char_type* __s1, const char_type* __s2, std::size_t __n) + { + for (std::size_t __i = 0; __i < __n; ++__i) + if (lt(__s1[__i], __s2[__i])) + return -1; + else if (lt(__s2[__i], __s1[__i])) + return 1; + return 0; + } + + template + std::size_t + char_traits<_CharT>:: + length(const char_type* __p) + { + std::size_t __i = 0; + while (!eq(__p[__i], char_type())) + ++__i; + return __i; + } + + template + const typename char_traits<_CharT>::char_type* + char_traits<_CharT>:: + find(const char_type* __s, std::size_t __n, const char_type& __a) + { + for (std::size_t __i = 0; __i < __n; ++__i) + if (eq(__s[__i], __a)) + return __s + __i; + return 0; + } + + template + typename char_traits<_CharT>::char_type* + char_traits<_CharT>:: + move(char_type* __s1, const char_type* __s2, std::size_t __n) + { + return static_cast<_CharT*>(__builtin_memmove(__s1, __s2, + __n * sizeof(char_type))); + } + + template + typename char_traits<_CharT>::char_type* + char_traits<_CharT>:: + copy(char_type* __s1, const char_type* __s2, std::size_t __n) + { + + std::copy(__s2, __s2 + __n, __s1); + return __s1; + } + + template + typename char_traits<_CharT>::char_type* + char_traits<_CharT>:: + assign(char_type* __s, std::size_t __n, char_type __a) + { + + std::fill_n(__s, __n, __a); + return __s; + } + + +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 226 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 3 + template + struct char_traits : public __gnu_cxx::char_traits<_CharT> + { }; + + + + template<> + struct char_traits + { + typedef char char_type; + typedef int int_type; + typedef streampos pos_type; + typedef streamoff off_type; + typedef mbstate_t state_type; + + static void + assign(char_type& __c1, const char_type& __c2) noexcept + { __c1 = __c2; } + + static constexpr bool + eq(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 == __c2; } + + static constexpr bool + lt(const char_type& __c1, const char_type& __c2) noexcept + { + + return (static_cast(__c1) + < static_cast(__c2)); + } + + static int + compare(const char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n == 0) + return 0; + return __builtin_memcmp(__s1, __s2, __n); + } + + static size_t + length(const char_type* __s) + { return __builtin_strlen(__s); } + + static const char_type* + find(const char_type* __s, size_t __n, const char_type& __a) + { + if (__n == 0) + return 0; + return static_cast(__builtin_memchr(__s, __a, __n)); + } + + static char_type* + move(char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n == 0) + return __s1; + return static_cast(__builtin_memmove(__s1, __s2, __n)); + } + + static char_type* + copy(char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n == 0) + return __s1; + return static_cast(__builtin_memcpy(__s1, __s2, __n)); + } + + static char_type* + assign(char_type* __s, size_t __n, char_type __a) + { + if (__n == 0) + return __s; + return static_cast(__builtin_memset(__s, __a, __n)); + } + + static constexpr char_type + to_char_type(const int_type& __c) noexcept + { return static_cast(__c); } + + + + static constexpr int_type + to_int_type(const char_type& __c) noexcept + { return static_cast(static_cast(__c)); } + + static constexpr bool + eq_int_type(const int_type& __c1, const int_type& __c2) noexcept + { return __c1 == __c2; } + + static constexpr int_type + eof() noexcept + { return static_cast(-1); } + + static constexpr int_type + not_eof(const int_type& __c) noexcept + { return (__c == eof()) ? 0 : __c; } + }; + + + + + template<> + struct char_traits + { + typedef wchar_t char_type; + typedef wint_t int_type; + typedef streamoff off_type; + typedef wstreampos pos_type; + typedef mbstate_t state_type; + + static void + assign(char_type& __c1, const char_type& __c2) noexcept + { __c1 = __c2; } + + static constexpr bool + eq(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 == __c2; } + + static constexpr bool + lt(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 < __c2; } + + static int + compare(const char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n == 0) + return 0; + return wmemcmp(__s1, __s2, __n); + } + + static size_t + length(const char_type* __s) + { return wcslen(__s); } + + static const char_type* + find(const char_type* __s, size_t __n, const char_type& __a) + { + if (__n == 0) + return 0; + return wmemchr(__s, __a, __n); + } + + static char_type* + move(char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n == 0) + return __s1; + return wmemmove(__s1, __s2, __n); + } + + static char_type* + copy(char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n == 0) + return __s1; + return wmemcpy(__s1, __s2, __n); + } + + static char_type* + assign(char_type* __s, size_t __n, char_type __a) + { + if (__n == 0) + return __s; + return wmemset(__s, __a, __n); + } + + static constexpr char_type + to_char_type(const int_type& __c) noexcept + { return char_type(__c); } + + static constexpr int_type + to_int_type(const char_type& __c) noexcept + { return int_type(__c); } + + static constexpr bool + eq_int_type(const int_type& __c1, const int_type& __c2) noexcept + { return __c1 == __c2; } + + static constexpr int_type + eof() noexcept + { return static_cast((0xffffffffu)); } + + static constexpr int_type + not_eof(const int_type& __c) noexcept + { return eq_int_type(__c, eof()) ? 0 : __c; } + }; + + + +} + + + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdint" 1 3 +# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdint" 3 +# 46 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdint" 3 +namespace std +{ + using ::int8_t; + using ::int16_t; + using ::int32_t; + using ::int64_t; + + using ::int_fast8_t; + using ::int_fast16_t; + using ::int_fast32_t; + using ::int_fast64_t; + + using ::int_least8_t; + using ::int_least16_t; + using ::int_least32_t; + using ::int_least64_t; + + using ::intmax_t; + using ::intptr_t; + + using ::uint8_t; + using ::uint16_t; + using ::uint32_t; + using ::uint64_t; + + using ::uint_fast8_t; + using ::uint_fast16_t; + using ::uint_fast32_t; + using ::uint_fast64_t; + + using ::uint_least8_t; + using ::uint_least16_t; + using ::uint_least32_t; + using ::uint_least64_t; + + using ::uintmax_t; + using ::uintptr_t; +} +# 421 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template<> + struct char_traits + { + typedef char16_t char_type; + typedef uint_least16_t int_type; + typedef streamoff off_type; + typedef u16streampos pos_type; + typedef mbstate_t state_type; + + static void + assign(char_type& __c1, const char_type& __c2) noexcept + { __c1 = __c2; } + + static constexpr bool + eq(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 == __c2; } + + static constexpr bool + lt(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 < __c2; } + + static int + compare(const char_type* __s1, const char_type* __s2, size_t __n) + { + for (size_t __i = 0; __i < __n; ++__i) + if (lt(__s1[__i], __s2[__i])) + return -1; + else if (lt(__s2[__i], __s1[__i])) + return 1; + return 0; + } + + static size_t + length(const char_type* __s) + { + size_t __i = 0; + while (!eq(__s[__i], char_type())) + ++__i; + return __i; + } + + static const char_type* + find(const char_type* __s, size_t __n, const char_type& __a) + { + for (size_t __i = 0; __i < __n; ++__i) + if (eq(__s[__i], __a)) + return __s + __i; + return 0; + } + + static char_type* + move(char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n == 0) + return __s1; + return (static_cast + (__builtin_memmove(__s1, __s2, __n * sizeof(char_type)))); + } + + static char_type* + copy(char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n == 0) + return __s1; + return (static_cast + (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type)))); + } + + static char_type* + assign(char_type* __s, size_t __n, char_type __a) + { + for (size_t __i = 0; __i < __n; ++__i) + assign(__s[__i], __a); + return __s; + } + + static constexpr char_type + to_char_type(const int_type& __c) noexcept + { return char_type(__c); } + + static constexpr int_type + to_int_type(const char_type& __c) noexcept + { return int_type(__c); } + + static constexpr bool + eq_int_type(const int_type& __c1, const int_type& __c2) noexcept + { return __c1 == __c2; } + + static constexpr int_type + eof() noexcept + { return static_cast(-1); } + + static constexpr int_type + not_eof(const int_type& __c) noexcept + { return eq_int_type(__c, eof()) ? 0 : __c; } + }; + + template<> + struct char_traits + { + typedef char32_t char_type; + typedef uint_least32_t int_type; + typedef streamoff off_type; + typedef u32streampos pos_type; + typedef mbstate_t state_type; + + static void + assign(char_type& __c1, const char_type& __c2) noexcept + { __c1 = __c2; } + + static constexpr bool + eq(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 == __c2; } + + static constexpr bool + lt(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 < __c2; } + + static int + compare(const char_type* __s1, const char_type* __s2, size_t __n) + { + for (size_t __i = 0; __i < __n; ++__i) + if (lt(__s1[__i], __s2[__i])) + return -1; + else if (lt(__s2[__i], __s1[__i])) + return 1; + return 0; + } + + static size_t + length(const char_type* __s) + { + size_t __i = 0; + while (!eq(__s[__i], char_type())) + ++__i; + return __i; + } + + static const char_type* + find(const char_type* __s, size_t __n, const char_type& __a) + { + for (size_t __i = 0; __i < __n; ++__i) + if (eq(__s[__i], __a)) + return __s + __i; + return 0; + } + + static char_type* + move(char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n == 0) + return __s1; + return (static_cast + (__builtin_memmove(__s1, __s2, __n * sizeof(char_type)))); + } + + static char_type* + copy(char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n == 0) + return __s1; + return (static_cast + (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type)))); + } + + static char_type* + assign(char_type* __s, size_t __n, char_type __a) + { + for (size_t __i = 0; __i < __n; ++__i) + assign(__s[__i], __a); + return __s; + } + + static constexpr char_type + to_char_type(const int_type& __c) noexcept + { return char_type(__c); } + + static constexpr int_type + to_int_type(const char_type& __c) noexcept + { return int_type(__c); } + + static constexpr bool + eq_int_type(const int_type& __c1, const int_type& __c2) noexcept + { return __c1 == __c2; } + + static constexpr int_type + eof() noexcept + { return static_cast(-1); } + + static constexpr int_type + not_eof(const int_type& __c) noexcept + { return eq_int_type(__c, eof()) ? 0 : __c; } + }; + + +} +# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/localefwd.h" 1 3 +# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/localefwd.h" 3 + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++locale.h" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++locale.h" 3 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/clocale" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/clocale" 3 + + +# 1 "/usr/include/locale.h" 1 3 4 +# 28 "/usr/include/locale.h" 3 4 +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4 +# 29 "/usr/include/locale.h" 2 3 4 +# 1 "/usr/include/bits/locale.h" 1 3 4 +# 30 "/usr/include/locale.h" 2 3 4 + +extern "C" { +# 53 "/usr/include/locale.h" 3 4 +struct lconv +{ + + + char *decimal_point; + char *thousands_sep; + + + + + + char *grouping; + + + + + + char *int_curr_symbol; + char *currency_symbol; + char *mon_decimal_point; + char *mon_thousands_sep; + char *mon_grouping; + char *positive_sign; + char *negative_sign; + char int_frac_digits; + char frac_digits; + + char p_cs_precedes; + + char p_sep_by_space; + + char n_cs_precedes; + + char n_sep_by_space; + + + + + + + char p_sign_posn; + char n_sign_posn; + + + char int_p_cs_precedes; + + char int_p_sep_by_space; + + char int_n_cs_precedes; + + char int_n_sep_by_space; + + + + + + + char int_p_sign_posn; + char int_n_sign_posn; +# 120 "/usr/include/locale.h" 3 4 +}; + + + +extern char *setlocale (int __category, const char *__locale) throw (); + + +extern struct lconv *localeconv (void) throw (); +# 151 "/usr/include/locale.h" 3 4 +extern __locale_t newlocale (int __category_mask, const char *__locale, + __locale_t __base) throw (); +# 186 "/usr/include/locale.h" 3 4 +extern __locale_t duplocale (__locale_t __dataset) throw (); + + + +extern void freelocale (__locale_t __dataset) throw (); + + + + + + +extern __locale_t uselocale (__locale_t __dataset) throw (); + + + + + + + +} +# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/clocale" 2 3 + + + + + + + + +namespace std +{ + using ::lconv; + using ::setlocale; + using ::localeconv; +} +# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++locale.h" 2 3 + + + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + extern "C" __typeof(uselocale) __uselocale; + + +} + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + typedef __locale_t __c_locale; + + + + + + inline int + __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)), + char* __out, + const int __size __attribute__ ((__unused__)), + const char* __fmt, ...) + { + + __c_locale __old = __gnu_cxx::__uselocale(__cloc); +# 88 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++locale.h" 3 + __builtin_va_list __args; + __builtin_va_start(__args, __fmt); + + + const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args); + + + + + __builtin_va_end(__args); + + + __gnu_cxx::__uselocale(__old); + + + + + + + + return __ret; + } + + +} +# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/localefwd.h" 2 3 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cctype" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cctype" 3 + + +# 1 "/usr/include/ctype.h" 1 3 4 +# 28 "/usr/include/ctype.h" 3 4 +extern "C" { +# 46 "/usr/include/ctype.h" 3 4 +enum +{ + _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), + _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), + _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), + _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), + _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), + _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), + _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), + _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), + _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), + _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), + _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), + _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8)) +}; +# 79 "/usr/include/ctype.h" 3 4 +extern const unsigned short int **__ctype_b_loc (void) + throw () __attribute__ ((__const__)); +extern const __int32_t **__ctype_tolower_loc (void) + throw () __attribute__ ((__const__)); +extern const __int32_t **__ctype_toupper_loc (void) + throw () __attribute__ ((__const__)); +# 110 "/usr/include/ctype.h" 3 4 +extern int isalnum (int) throw (); +extern int isalpha (int) throw (); +extern int iscntrl (int) throw (); +extern int isdigit (int) throw (); +extern int islower (int) throw (); +extern int isgraph (int) throw (); +extern int isprint (int) throw (); +extern int ispunct (int) throw (); +extern int isspace (int) throw (); +extern int isupper (int) throw (); +extern int isxdigit (int) throw (); + + + +extern int tolower (int __c) throw (); + + +extern int toupper (int __c) throw (); +# 136 "/usr/include/ctype.h" 3 4 +extern int isblank (int) throw (); + + + + + + +extern int isctype (int __c, int __mask) throw (); + + + + + + +extern int isascii (int __c) throw (); + + + +extern int toascii (int __c) throw (); + + + +extern int _toupper (int) throw (); +extern int _tolower (int) throw (); +# 271 "/usr/include/ctype.h" 3 4 +extern int isalnum_l (int, __locale_t) throw (); +extern int isalpha_l (int, __locale_t) throw (); +extern int iscntrl_l (int, __locale_t) throw (); +extern int isdigit_l (int, __locale_t) throw (); +extern int islower_l (int, __locale_t) throw (); +extern int isgraph_l (int, __locale_t) throw (); +extern int isprint_l (int, __locale_t) throw (); +extern int ispunct_l (int, __locale_t) throw (); +extern int isspace_l (int, __locale_t) throw (); +extern int isupper_l (int, __locale_t) throw (); +extern int isxdigit_l (int, __locale_t) throw (); + +extern int isblank_l (int, __locale_t) throw (); + + + +extern int __tolower_l (int __c, __locale_t __l) throw (); +extern int tolower_l (int __c, __locale_t __l) throw (); + + +extern int __toupper_l (int __c, __locale_t __l) throw (); +extern int toupper_l (int __c, __locale_t __l) throw (); +# 347 "/usr/include/ctype.h" 3 4 +} +# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cctype" 2 3 +# 62 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cctype" 3 +namespace std +{ + using ::isalnum; + using ::isalpha; + using ::iscntrl; + using ::isdigit; + using ::isgraph; + using ::islower; + using ::isprint; + using ::ispunct; + using ::isspace; + using ::isupper; + using ::isxdigit; + using ::tolower; + using ::toupper; +} + + + + + + + +namespace std +{ + using ::isblank; +} +# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/localefwd.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 55 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/localefwd.h" 3 + class locale; + + template + bool + has_facet(const locale&) throw(); + + template + const _Facet& + use_facet(const locale&); + + + template + bool + isspace(_CharT, const locale&); + + template + bool + isprint(_CharT, const locale&); + + template + bool + iscntrl(_CharT, const locale&); + + template + bool + isupper(_CharT, const locale&); + + template + bool + islower(_CharT, const locale&); + + template + bool + isalpha(_CharT, const locale&); + + template + bool + isdigit(_CharT, const locale&); + + template + bool + ispunct(_CharT, const locale&); + + template + bool + isxdigit(_CharT, const locale&); + + template + bool + isalnum(_CharT, const locale&); + + template + bool + isgraph(_CharT, const locale&); + + + template + bool + isblank(_CharT, const locale&); + + + template + _CharT + toupper(_CharT, const locale&); + + template + _CharT + tolower(_CharT, const locale&); + + + class ctype_base; + template + class ctype; + template<> class ctype; + + template<> class ctype; + + template + class ctype_byname; + + + class codecvt_base; + template + class codecvt; + template<> class codecvt; + + template<> class codecvt; + + template + class codecvt_byname; + + + + template > + class num_get; + template > + class num_put; + +namespace __cxx11 { + template class numpunct; + template class numpunct_byname; +} + +namespace __cxx11 { + + template + class collate; + template + class collate_byname; +} + + + class time_base; +namespace __cxx11 { + template > + class time_get; + template > + class time_get_byname; +} + template > + class time_put; + template > + class time_put_byname; + + + class money_base; +namespace __cxx11 { + template > + class money_get; + template > + class money_put; +} +namespace __cxx11 { + template + class moneypunct; + template + class moneypunct_byname; +} + + + class messages_base; +namespace __cxx11 { + template + class messages; + template + class messages_byname; +} + + +} +# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 1 3 +# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/atomicity.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/atomicity.h" 3 + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr.h" 1 3 +# 30 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr.h" 3 +#pragma GCC visibility push(default) +# 148 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr.h" 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 1 3 +# 35 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3 +# 1 "/usr/include/pthread.h" 1 3 4 +# 23 "/usr/include/pthread.h" 3 4 +# 1 "/usr/include/sched.h" 1 3 4 +# 28 "/usr/include/sched.h" 3 4 +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4 +# 29 "/usr/include/sched.h" 2 3 4 + + + + + +# 1 "/usr/include/time.h" 1 3 4 +# 35 "/usr/include/sched.h" 2 3 4 + + + + + + + + +# 1 "/usr/include/bits/sched.h" 1 3 4 +# 73 "/usr/include/bits/sched.h" 3 4 +struct sched_param + { + int __sched_priority; + }; + +extern "C" { + + + +extern int clone (int (*__fn) (void *__arg), void *__child_stack, + int __flags, void *__arg, ...) throw (); + + +extern int unshare (int __flags) throw (); + + +extern int sched_getcpu (void) throw (); + + +extern int setns (int __fd, int __nstype) throw (); + + + +} + + + + + + + +struct __sched_param + { + int __sched_priority; + }; +# 119 "/usr/include/bits/sched.h" 3 4 +typedef unsigned long int __cpu_mask; + + + + + + +typedef struct +{ + __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))]; +} cpu_set_t; +# 202 "/usr/include/bits/sched.h" 3 4 +extern "C" { + +extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp) + throw (); +extern cpu_set_t *__sched_cpualloc (size_t __count) throw () ; +extern void __sched_cpufree (cpu_set_t *__set) throw (); + +} +# 44 "/usr/include/sched.h" 2 3 4 + + + + +extern "C" { + + +extern int sched_setparam (__pid_t __pid, const struct sched_param *__param) + throw (); + + +extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw (); + + +extern int sched_setscheduler (__pid_t __pid, int __policy, + const struct sched_param *__param) throw (); + + +extern int sched_getscheduler (__pid_t __pid) throw (); + + +extern int sched_yield (void) throw (); + + +extern int sched_get_priority_max (int __algorithm) throw (); + + +extern int sched_get_priority_min (int __algorithm) throw (); + + +extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw (); +# 118 "/usr/include/sched.h" 3 4 +extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize, + const cpu_set_t *__cpuset) throw (); + + +extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize, + cpu_set_t *__cpuset) throw (); + + +} +# 24 "/usr/include/pthread.h" 2 3 4 +# 1 "/usr/include/time.h" 1 3 4 +# 29 "/usr/include/time.h" 3 4 +extern "C" { + + + + + + + + +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4 +# 38 "/usr/include/time.h" 2 3 4 + + + +# 1 "/usr/include/bits/time.h" 1 3 4 +# 88 "/usr/include/bits/time.h" 3 4 +# 1 "/usr/include/bits/timex.h" 1 3 4 +# 25 "/usr/include/bits/timex.h" 3 4 +struct timex +{ + unsigned int modes; + __syscall_slong_t offset; + __syscall_slong_t freq; + __syscall_slong_t maxerror; + __syscall_slong_t esterror; + int status; + __syscall_slong_t constant; + __syscall_slong_t precision; + __syscall_slong_t tolerance; + struct timeval time; + __syscall_slong_t tick; + __syscall_slong_t ppsfreq; + __syscall_slong_t jitter; + int shift; + __syscall_slong_t stabil; + __syscall_slong_t jitcnt; + __syscall_slong_t calcnt; + __syscall_slong_t errcnt; + __syscall_slong_t stbcnt; + + int tai; + + + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; +}; +# 89 "/usr/include/bits/time.h" 2 3 4 + +extern "C" { + + +extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw (); + +} +# 42 "/usr/include/time.h" 2 3 4 +# 133 "/usr/include/time.h" 3 4 +struct tm +{ + int tm_sec; + int tm_min; + int tm_hour; + int tm_mday; + int tm_mon; + int tm_year; + int tm_wday; + int tm_yday; + int tm_isdst; + + + long int tm_gmtoff; + const char *tm_zone; + + + + +}; +# 161 "/usr/include/time.h" 3 4 +struct itimerspec + { + struct timespec it_interval; + struct timespec it_value; + }; + + +struct sigevent; +# 189 "/usr/include/time.h" 3 4 +extern clock_t clock (void) throw (); + + +extern time_t time (time_t *__timer) throw (); + + +extern double difftime (time_t __time1, time_t __time0) + throw () __attribute__ ((__const__)); + + +extern time_t mktime (struct tm *__tp) throw (); + + + + + +extern size_t strftime (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp) throw (); + + + + + +extern char *strptime (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp) + throw (); + + + + + + + +extern size_t strftime_l (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp, + __locale_t __loc) throw (); + + + +extern char *strptime_l (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp, + __locale_t __loc) throw (); + + + + + + +extern struct tm *gmtime (const time_t *__timer) throw (); + + + +extern struct tm *localtime (const time_t *__timer) throw (); + + + + + +extern struct tm *gmtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) throw (); + + + +extern struct tm *localtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) throw (); + + + + + +extern char *asctime (const struct tm *__tp) throw (); + + +extern char *ctime (const time_t *__timer) throw (); + + + + + + + +extern char *asctime_r (const struct tm *__restrict __tp, + char *__restrict __buf) throw (); + + +extern char *ctime_r (const time_t *__restrict __timer, + char *__restrict __buf) throw (); + + + + +extern char *__tzname[2]; +extern int __daylight; +extern long int __timezone; + + + + +extern char *tzname[2]; + + + +extern void tzset (void) throw (); + + + +extern int daylight; +extern long int timezone; + + + + + +extern int stime (const time_t *__when) throw (); +# 319 "/usr/include/time.h" 3 4 +extern time_t timegm (struct tm *__tp) throw (); + + +extern time_t timelocal (struct tm *__tp) throw (); + + +extern int dysize (int __year) throw () __attribute__ ((__const__)); +# 334 "/usr/include/time.h" 3 4 +extern int nanosleep (const struct timespec *__requested_time, + struct timespec *__remaining); + + + +extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw (); + + +extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw (); + + +extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp) + throw (); + + + + + + +extern int clock_nanosleep (clockid_t __clock_id, int __flags, + const struct timespec *__req, + struct timespec *__rem); + + +extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw (); + + + + +extern int timer_create (clockid_t __clock_id, + struct sigevent *__restrict __evp, + timer_t *__restrict __timerid) throw (); + + +extern int timer_delete (timer_t __timerid) throw (); + + +extern int timer_settime (timer_t __timerid, int __flags, + const struct itimerspec *__restrict __value, + struct itimerspec *__restrict __ovalue) throw (); + + +extern int timer_gettime (timer_t __timerid, struct itimerspec *__value) + throw (); + + +extern int timer_getoverrun (timer_t __timerid) throw (); + + + + + +extern int timespec_get (struct timespec *__ts, int __base) + throw () __attribute__ ((__nonnull__ (1))); +# 403 "/usr/include/time.h" 3 4 +extern int getdate_err; +# 412 "/usr/include/time.h" 3 4 +extern struct tm *getdate (const char *__string); +# 426 "/usr/include/time.h" 3 4 +extern int getdate_r (const char *__restrict __string, + struct tm *__restrict __resbufp); + + +} +# 25 "/usr/include/pthread.h" 2 3 4 + + +# 1 "/usr/include/bits/setjmp.h" 1 3 4 +# 26 "/usr/include/bits/setjmp.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 27 "/usr/include/bits/setjmp.h" 2 3 4 + + + + +typedef long int __jmp_buf[8]; +# 28 "/usr/include/pthread.h" 2 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 29 "/usr/include/pthread.h" 2 3 4 + + + +enum +{ + PTHREAD_CREATE_JOINABLE, + + PTHREAD_CREATE_DETACHED + +}; + + + +enum +{ + PTHREAD_MUTEX_TIMED_NP, + PTHREAD_MUTEX_RECURSIVE_NP, + PTHREAD_MUTEX_ERRORCHECK_NP, + PTHREAD_MUTEX_ADAPTIVE_NP + + , + PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP, + PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, + PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, + PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL + + + + , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP + +}; + + + + +enum +{ + PTHREAD_MUTEX_STALLED, + PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED, + PTHREAD_MUTEX_ROBUST, + PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST +}; + + + + + +enum +{ + PTHREAD_PRIO_NONE, + PTHREAD_PRIO_INHERIT, + PTHREAD_PRIO_PROTECT +}; +# 114 "/usr/include/pthread.h" 3 4 +enum +{ + PTHREAD_RWLOCK_PREFER_READER_NP, + PTHREAD_RWLOCK_PREFER_WRITER_NP, + PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, + PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP +}; +# 155 "/usr/include/pthread.h" 3 4 +enum +{ + PTHREAD_INHERIT_SCHED, + + PTHREAD_EXPLICIT_SCHED + +}; + + + +enum +{ + PTHREAD_SCOPE_SYSTEM, + + PTHREAD_SCOPE_PROCESS + +}; + + + +enum +{ + PTHREAD_PROCESS_PRIVATE, + + PTHREAD_PROCESS_SHARED + +}; +# 190 "/usr/include/pthread.h" 3 4 +struct _pthread_cleanup_buffer +{ + void (*__routine) (void *); + void *__arg; + int __canceltype; + struct _pthread_cleanup_buffer *__prev; +}; + + +enum +{ + PTHREAD_CANCEL_ENABLE, + + PTHREAD_CANCEL_DISABLE + +}; +enum +{ + PTHREAD_CANCEL_DEFERRED, + + PTHREAD_CANCEL_ASYNCHRONOUS + +}; +# 228 "/usr/include/pthread.h" 3 4 +extern "C" { + + + + +extern int pthread_create (pthread_t *__restrict __newthread, + const pthread_attr_t *__restrict __attr, + void *(*__start_routine) (void *), + void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3))); + + + + + +extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__)); + + + + + + + +extern int pthread_join (pthread_t __th, void **__thread_return); + + + + +extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw (); + + + + + + + +extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return, + const struct timespec *__abstime); + + + + + + +extern int pthread_detach (pthread_t __th) throw (); + + + +extern pthread_t pthread_self (void) throw () __attribute__ ((__const__)); + + +extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) + throw () __attribute__ ((__const__)); + + + + + + + +extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_attr_destroy (pthread_attr_t *__attr) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr, + int *__detachstate) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setdetachstate (pthread_attr_t *__attr, + int __detachstate) + throw () __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_attr_getguardsize (const pthread_attr_t *__attr, + size_t *__guardsize) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setguardsize (pthread_attr_t *__attr, + size_t __guardsize) + throw () __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr, + struct sched_param *__restrict __param) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr, + const struct sched_param *__restrict + __param) throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict + __attr, int *__restrict __policy) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict + __attr, int *__restrict __inherit) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setinheritsched (pthread_attr_t *__attr, + int __inherit) + throw () __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr, + int *__restrict __scope) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict + __attr, void **__restrict __stackaddr) + throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__)); + + + + + +extern int pthread_attr_setstackaddr (pthread_attr_t *__attr, + void *__stackaddr) + throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)); + + +extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict + __attr, size_t *__restrict __stacksize) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + +extern int pthread_attr_setstacksize (pthread_attr_t *__attr, + size_t __stacksize) + throw () __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr, + void **__restrict __stackaddr, + size_t *__restrict __stacksize) + throw () __attribute__ ((__nonnull__ (1, 2, 3))); + + + + +extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr, + size_t __stacksize) throw () __attribute__ ((__nonnull__ (1))); + + + + + +extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr, + size_t __cpusetsize, + const cpu_set_t *__cpuset) + throw () __attribute__ ((__nonnull__ (1, 3))); + + + +extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr, + size_t __cpusetsize, + cpu_set_t *__cpuset) + throw () __attribute__ ((__nonnull__ (1, 3))); + + +extern int pthread_getattr_default_np (pthread_attr_t *__attr) + throw () __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_setattr_default_np (const pthread_attr_t *__attr) + throw () __attribute__ ((__nonnull__ (1))); + + + + +extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr) + throw () __attribute__ ((__nonnull__ (2))); + + + + + + + +extern int pthread_setschedparam (pthread_t __target_thread, int __policy, + const struct sched_param *__param) + throw () __attribute__ ((__nonnull__ (3))); + + +extern int pthread_getschedparam (pthread_t __target_thread, + int *__restrict __policy, + struct sched_param *__restrict __param) + throw () __attribute__ ((__nonnull__ (2, 3))); + + +extern int pthread_setschedprio (pthread_t __target_thread, int __prio) + throw (); + + + + +extern int pthread_getname_np (pthread_t __target_thread, char *__buf, + size_t __buflen) + throw () __attribute__ ((__nonnull__ (2))); + + +extern int pthread_setname_np (pthread_t __target_thread, const char *__name) + throw () __attribute__ ((__nonnull__ (2))); + + + + + +extern int pthread_getconcurrency (void) throw (); + + +extern int pthread_setconcurrency (int __level) throw (); + + + + + + + +extern int pthread_yield (void) throw (); + + + + +extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize, + const cpu_set_t *__cpuset) + throw () __attribute__ ((__nonnull__ (3))); + + +extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize, + cpu_set_t *__cpuset) + throw () __attribute__ ((__nonnull__ (3))); +# 494 "/usr/include/pthread.h" 3 4 +extern int pthread_once (pthread_once_t *__once_control, + void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2))); +# 506 "/usr/include/pthread.h" 3 4 +extern int pthread_setcancelstate (int __state, int *__oldstate); + + + +extern int pthread_setcanceltype (int __type, int *__oldtype); + + +extern int pthread_cancel (pthread_t __th); + + + + +extern void pthread_testcancel (void); + + + + +typedef struct +{ + struct + { + __jmp_buf __cancel_jmp_buf; + int __mask_was_saved; + } __cancel_jmp_buf[1]; + void *__pad[4]; +} __pthread_unwind_buf_t __attribute__ ((__aligned__)); +# 540 "/usr/include/pthread.h" 3 4 +struct __pthread_cleanup_frame +{ + void (*__cancel_routine) (void *); + void *__cancel_arg; + int __do_it; + int __cancel_type; +}; + + + + +class __pthread_cleanup_class +{ + void (*__cancel_routine) (void *); + void *__cancel_arg; + int __do_it; + int __cancel_type; + + public: + __pthread_cleanup_class (void (*__fct) (void *), void *__arg) + : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { } + ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); } + void __setdoit (int __newval) { __do_it = __newval; } + void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, + &__cancel_type); } + void __restore () const { pthread_setcanceltype (__cancel_type, 0); } +}; +# 742 "/usr/include/pthread.h" 3 4 +struct __jmp_buf_tag; +extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw (); + + + + + +extern int pthread_mutex_init (pthread_mutex_t *__mutex, + const pthread_mutexattr_t *__mutexattr) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutex_destroy (pthread_mutex_t *__mutex) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutex_lock (pthread_mutex_t *__mutex) + throw () __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex, + const struct timespec *__restrict + __abstime) throw () __attribute__ ((__nonnull__ (1, 2))); + + + +extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) + throw () __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_mutex_getprioceiling (const pthread_mutex_t * + __restrict __mutex, + int *__restrict __prioceiling) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + +extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex, + int __prioceiling, + int *__restrict __old_ceiling) + throw () __attribute__ ((__nonnull__ (1, 3))); + + + + +extern int pthread_mutex_consistent (pthread_mutex_t *__mutex) + throw () __attribute__ ((__nonnull__ (1))); + +extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex) + throw () __attribute__ ((__nonnull__ (1))); +# 806 "/usr/include/pthread.h" 3 4 +extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t * + __restrict __attr, + int *__restrict __pshared) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr, + int __pshared) + throw () __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict + __attr, int *__restrict __kind) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + +extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind) + throw () __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t * + __restrict __attr, + int *__restrict __protocol) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + +extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr, + int __protocol) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t * + __restrict __attr, + int *__restrict __prioceiling) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr, + int __prioceiling) + throw () __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr, + int *__robustness) + throw () __attribute__ ((__nonnull__ (1, 2))); + +extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr, + int *__robustness) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + +extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr, + int __robustness) + throw () __attribute__ ((__nonnull__ (1))); + +extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr, + int __robustness) + throw () __attribute__ ((__nonnull__ (1))); +# 888 "/usr/include/pthread.h" 3 4 +extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock, + const pthread_rwlockattr_t *__restrict + __attr) throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) + throw () __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock, + const struct timespec *__restrict + __abstime) throw () __attribute__ ((__nonnull__ (1, 2))); + + + +extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) + throw () __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock, + const struct timespec *__restrict + __abstime) throw () __attribute__ ((__nonnull__ (1, 2))); + + + +extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) + throw () __attribute__ ((__nonnull__ (1))); + + + + + +extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * + __restrict __attr, + int *__restrict __pshared) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr, + int __pshared) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t * + __restrict __attr, + int *__restrict __pref) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr, + int __pref) throw () __attribute__ ((__nonnull__ (1))); + + + + + + + +extern int pthread_cond_init (pthread_cond_t *__restrict __cond, + const pthread_condattr_t *__restrict __cond_attr) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_cond_destroy (pthread_cond_t *__cond) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_cond_signal (pthread_cond_t *__cond) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_cond_broadcast (pthread_cond_t *__cond) + throw () __attribute__ ((__nonnull__ (1))); + + + + + + +extern int pthread_cond_wait (pthread_cond_t *__restrict __cond, + pthread_mutex_t *__restrict __mutex) + __attribute__ ((__nonnull__ (1, 2))); +# 1000 "/usr/include/pthread.h" 3 4 +extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond, + pthread_mutex_t *__restrict __mutex, + const struct timespec *__restrict __abstime) + __attribute__ ((__nonnull__ (1, 2, 3))); + + + + +extern int pthread_condattr_init (pthread_condattr_t *__attr) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_condattr_destroy (pthread_condattr_t *__attr) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_condattr_getpshared (const pthread_condattr_t * + __restrict __attr, + int *__restrict __pshared) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_condattr_setpshared (pthread_condattr_t *__attr, + int __pshared) throw () __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_condattr_getclock (const pthread_condattr_t * + __restrict __attr, + __clockid_t *__restrict __clock_id) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_condattr_setclock (pthread_condattr_t *__attr, + __clockid_t __clock_id) + throw () __attribute__ ((__nonnull__ (1))); +# 1044 "/usr/include/pthread.h" 3 4 +extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_spin_destroy (pthread_spinlock_t *__lock) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_spin_lock (pthread_spinlock_t *__lock) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_spin_trylock (pthread_spinlock_t *__lock) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_spin_unlock (pthread_spinlock_t *__lock) + throw () __attribute__ ((__nonnull__ (1))); + + + + + + +extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier, + const pthread_barrierattr_t *__restrict + __attr, unsigned int __count) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_barrier_destroy (pthread_barrier_t *__barrier) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_barrier_wait (pthread_barrier_t *__barrier) + throw () __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t * + __restrict __attr, + int *__restrict __pshared) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr, + int __pshared) + throw () __attribute__ ((__nonnull__ (1))); +# 1111 "/usr/include/pthread.h" 3 4 +extern int pthread_key_create (pthread_key_t *__key, + void (*__destr_function) (void *)) + throw () __attribute__ ((__nonnull__ (1))); + + +extern int pthread_key_delete (pthread_key_t __key) throw (); + + +extern void *pthread_getspecific (pthread_key_t __key) throw (); + + +extern int pthread_setspecific (pthread_key_t __key, + const void *__pointer) throw () ; + + + + +extern int pthread_getcpuclockid (pthread_t __thread_id, + __clockid_t *__clock_id) + throw () __attribute__ ((__nonnull__ (2))); +# 1145 "/usr/include/pthread.h" 3 4 +extern int pthread_atfork (void (*__prepare) (void), + void (*__parent) (void), + void (*__child) (void)) throw (); +# 1159 "/usr/include/pthread.h" 3 4 +} +# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 2 3 +# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3 +typedef pthread_t __gthread_t; +typedef pthread_key_t __gthread_key_t; +typedef pthread_once_t __gthread_once_t; +typedef pthread_mutex_t __gthread_mutex_t; +typedef pthread_mutex_t __gthread_recursive_mutex_t; +typedef pthread_cond_t __gthread_cond_t; +typedef struct timespec __gthread_time_t; +# 101 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3 +static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once"))); +static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific"))); +static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific"))); + +static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create"))); +static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join"))); +static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal"))); +static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self"))); +static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach"))); + +static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel"))); + +static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield"))); + +static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock"))); +static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock"))); + +static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock"))); + +static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock"))); +static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init"))); +static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy"))); + +static __typeof(pthread_cond_init) __gthrw_pthread_cond_init __attribute__ ((__weakref__("pthread_cond_init"))); +static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast"))); +static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal"))); +static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait"))); +static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait"))); +static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy"))); + +static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create"))); +static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete"))); +static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init"))); +static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype"))); +static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy"))); +# 236 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3 +static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create"))); +# 246 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3 +static inline int +__gthread_active_p (void) +{ + static void *const __gthread_active_ptr + = __extension__ (void *) &__gthrw___pthread_key_create; + return __gthread_active_ptr != 0; +} +# 658 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3 +static inline int +__gthread_create (__gthread_t *__threadid, void *(*__func) (void*), + void *__args) +{ + return __gthrw_pthread_create (__threadid, __null, __func, __args); +} + +static inline int +__gthread_join (__gthread_t __threadid, void **__value_ptr) +{ + return __gthrw_pthread_join (__threadid, __value_ptr); +} + +static inline int +__gthread_detach (__gthread_t __threadid) +{ + return __gthrw_pthread_detach (__threadid); +} + +static inline int +__gthread_equal (__gthread_t __t1, __gthread_t __t2) +{ + return __gthrw_pthread_equal (__t1, __t2); +} + +static inline __gthread_t +__gthread_self (void) +{ + return __gthrw_pthread_self (); +} + +static inline int +__gthread_yield (void) +{ + return __gthrw_sched_yield (); +} + +static inline int +__gthread_once (__gthread_once_t *__once, void (*__func) (void)) +{ + if (__gthread_active_p ()) + return __gthrw_pthread_once (__once, __func); + else + return -1; +} + +static inline int +__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *)) +{ + return __gthrw_pthread_key_create (__key, __dtor); +} + +static inline int +__gthread_key_delete (__gthread_key_t __key) +{ + return __gthrw_pthread_key_delete (__key); +} + +static inline void * +__gthread_getspecific (__gthread_key_t __key) +{ + return __gthrw_pthread_getspecific (__key); +} + +static inline int +__gthread_setspecific (__gthread_key_t __key, const void *__ptr) +{ + return __gthrw_pthread_setspecific (__key, __ptr); +} + +static inline void +__gthread_mutex_init_function (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + __gthrw_pthread_mutex_init (__mutex, __null); +} + +static inline int +__gthread_mutex_destroy (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + return __gthrw_pthread_mutex_destroy (__mutex); + else + return 0; +} + +static inline int +__gthread_mutex_lock (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + return __gthrw_pthread_mutex_lock (__mutex); + else + return 0; +} + +static inline int +__gthread_mutex_trylock (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + return __gthrw_pthread_mutex_trylock (__mutex); + else + return 0; +} + + +static inline int +__gthread_mutex_timedlock (__gthread_mutex_t *__mutex, + const __gthread_time_t *__abs_timeout) +{ + if (__gthread_active_p ()) + return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout); + else + return 0; +} + + +static inline int +__gthread_mutex_unlock (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + return __gthrw_pthread_mutex_unlock (__mutex); + else + return 0; +} +# 807 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3 +static inline int +__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex) +{ + return __gthread_mutex_lock (__mutex); +} + +static inline int +__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex) +{ + return __gthread_mutex_trylock (__mutex); +} + + +static inline int +__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex, + const __gthread_time_t *__abs_timeout) +{ + return __gthread_mutex_timedlock (__mutex, __abs_timeout); +} + + +static inline int +__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex) +{ + return __gthread_mutex_unlock (__mutex); +} + +static inline int +__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex) +{ + return __gthread_mutex_destroy (__mutex); +} +# 849 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3 +static inline int +__gthread_cond_broadcast (__gthread_cond_t *__cond) +{ + return __gthrw_pthread_cond_broadcast (__cond); +} + +static inline int +__gthread_cond_signal (__gthread_cond_t *__cond) +{ + return __gthrw_pthread_cond_signal (__cond); +} + +static inline int +__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex) +{ + return __gthrw_pthread_cond_wait (__cond, __mutex); +} + +static inline int +__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex, + const __gthread_time_t *__abs_timeout) +{ + return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout); +} + +static inline int +__gthread_cond_wait_recursive (__gthread_cond_t *__cond, + __gthread_recursive_mutex_t *__mutex) +{ + return __gthread_cond_wait (__cond, __mutex); +} + +static inline int +__gthread_cond_destroy (__gthread_cond_t* __cond) +{ + return __gthrw_pthread_cond_destroy (__cond); +} +# 149 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr.h" 2 3 + + +#pragma GCC visibility pop +# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/atomicity.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/atomic_word.h" 1 3 +# 32 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/atomic_word.h" 3 +typedef int _Atomic_word; +# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/atomicity.h" 2 3 + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + static inline _Atomic_word + __exchange_and_add(volatile _Atomic_word* __mem, int __val) + { return __atomic_fetch_add(__mem, __val, 4); } + + static inline void + __atomic_add(volatile _Atomic_word* __mem, int __val) + { __atomic_fetch_add(__mem, __val, 4); } +# 64 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/atomicity.h" 3 + static inline _Atomic_word + __exchange_and_add_single(_Atomic_word* __mem, int __val) + { + _Atomic_word __result = *__mem; + *__mem += __val; + return __result; + } + + static inline void + __atomic_add_single(_Atomic_word* __mem, int __val) + { *__mem += __val; } + + static inline _Atomic_word + __attribute__ ((__unused__)) + __exchange_and_add_dispatch(_Atomic_word* __mem, int __val) + { + + if (__gthread_active_p()) + return __exchange_and_add(__mem, __val); + else + return __exchange_and_add_single(__mem, __val); + + + + } + + static inline void + __attribute__ ((__unused__)) + __atomic_add_dispatch(_Atomic_word* __mem, int __val) + { + + if (__gthread_active_p()) + __atomic_add(__mem, __val); + else + __atomic_add_single(__mem, __val); + + + + } + + +} +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 2 3 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 1 3 +# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 1 3 +# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 3 + + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/allocator.h" 1 3 +# 46 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/allocator.h" 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++allocator.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++allocator.h" 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/new_allocator.h" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/new_allocator.h" 3 +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + using std::size_t; + using std::ptrdiff_t; +# 57 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/new_allocator.h" 3 + template + class new_allocator + { + public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Tp* pointer; + typedef const _Tp* const_pointer; + typedef _Tp& reference; + typedef const _Tp& const_reference; + typedef _Tp value_type; + + template + struct rebind + { typedef new_allocator<_Tp1> other; }; + + + + + typedef std::true_type propagate_on_container_move_assignment; + + + new_allocator() noexcept { } + + new_allocator(const new_allocator&) noexcept { } + + template + new_allocator(const new_allocator<_Tp1>&) noexcept { } + + ~new_allocator() noexcept { } + + pointer + address(reference __x) const noexcept + { return std::__addressof(__x); } + + const_pointer + address(const_reference __x) const noexcept + { return std::__addressof(__x); } + + + + pointer + allocate(size_type __n, const void* = 0) + { + if (__n > this->max_size()) + std::__throw_bad_alloc(); + + return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp))); + } + + + void + deallocate(pointer __p, size_type) + { ::operator delete(__p); } + + size_type + max_size() const noexcept + { return size_t(-1) / sizeof(_Tp); } + + + template + void + construct(_Up* __p, _Args&&... __args) + { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } + + template + void + destroy(_Up* __p) { __p->~_Up(); } +# 135 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/new_allocator.h" 3 + }; + + template + inline bool + operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&) + { return true; } + + template + inline bool + operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&) + { return false; } + + +} +# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++allocator.h" 2 3 + + +namespace std +{ +# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++allocator.h" 3 + template + using __allocator_base = __gnu_cxx::new_allocator<_Tp>; +} +# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/allocator.h" 2 3 +# 57 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/allocator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 67 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/allocator.h" 3 + template<> + class allocator + { + public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef void* pointer; + typedef const void* const_pointer; + typedef void value_type; + + template + struct rebind + { typedef allocator<_Tp1> other; }; + + + + + typedef true_type propagate_on_container_move_assignment; + + typedef true_type is_always_equal; + + template + void + construct(_Up* __p, _Args&&... __args) + { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } + + template + void + destroy(_Up* __p) { __p->~_Up(); } + + }; +# 107 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/allocator.h" 3 + template + class allocator: public __allocator_base<_Tp> + { + public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Tp* pointer; + typedef const _Tp* const_pointer; + typedef _Tp& reference; + typedef const _Tp& const_reference; + typedef _Tp value_type; + + template + struct rebind + { typedef allocator<_Tp1> other; }; + + + + + typedef true_type propagate_on_container_move_assignment; + + typedef true_type is_always_equal; + + + allocator() throw() { } + + allocator(const allocator& __a) throw() + : __allocator_base<_Tp>(__a) { } + + template + allocator(const allocator<_Tp1>&) throw() { } + + ~allocator() throw() { } + + + }; + + template + inline bool + operator==(const allocator<_T1>&, const allocator<_T2>&) + noexcept + { return true; } + + template + inline bool + operator==(const allocator<_Tp>&, const allocator<_Tp>&) + noexcept + { return true; } + + template + inline bool + operator!=(const allocator<_T1>&, const allocator<_T2>&) + noexcept + { return false; } + + template + inline bool + operator!=(const allocator<_Tp>&, const allocator<_Tp>&) + noexcept + { return false; } + + + + + + + extern template class allocator; + extern template class allocator; + + + + + + + template + struct __alloc_swap + { static void _S_do_it(_Alloc&, _Alloc&) noexcept { } }; + + template + struct __alloc_swap<_Alloc, false> + { + static void + _S_do_it(_Alloc& __one, _Alloc& __two) noexcept + { + + if (__one != __two) + swap(__one, __two); + } + }; + + + template + struct __alloc_neq + { + static bool + _S_do_it(const _Alloc&, const _Alloc&) + { return false; } + }; + + template + struct __alloc_neq<_Alloc, false> + { + static bool + _S_do_it(const _Alloc& __one, const _Alloc& __two) + { return __one != __two; } + }; + + + template, + is_nothrow_move_constructible>::value> + struct __shrink_to_fit_aux + { static bool _S_do_it(_Tp&) noexcept { return false; } }; + + template + struct __shrink_to_fit_aux<_Tp, true> + { + static bool + _S_do_it(_Tp& __c) noexcept + { + + try + { + _Tp(__make_move_if_noexcept_iterator(__c.begin()), + __make_move_if_noexcept_iterator(__c.end()), + __c.get_allocator()).swap(__c); + return true; + } + catch(...) + { return false; } + + + + } + }; + + + +} +# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ostream_insert.h" 1 3 +# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ostream_insert.h" 3 + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/cxxabi_forced.h" 1 3 +# 35 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/cxxabi_forced.h" 3 + +#pragma GCC visibility push(default) + + +namespace __cxxabiv1 +{ + + + + + + + + class __forced_unwind + { + virtual ~__forced_unwind() throw(); + + + virtual void __pure_dummy() = 0; + }; +} + + +#pragma GCC visibility pop +# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ostream_insert.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + inline void + __ostream_write(basic_ostream<_CharT, _Traits>& __out, + const _CharT* __s, streamsize __n) + { + typedef basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const streamsize __put = __out.rdbuf()->sputn(__s, __n); + if (__put != __n) + __out.setstate(__ios_base::badbit); + } + + template + inline void + __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n) + { + typedef basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const _CharT __c = __out.fill(); + for (; __n > 0; --__n) + { + const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c); + if (_Traits::eq_int_type(__put, _Traits::eof())) + { + __out.setstate(__ios_base::badbit); + break; + } + } + } + + template + basic_ostream<_CharT, _Traits>& + __ostream_insert(basic_ostream<_CharT, _Traits>& __out, + const _CharT* __s, streamsize __n) + { + typedef basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + typename __ostream_type::sentry __cerb(__out); + if (__cerb) + { + try + { + const streamsize __w = __out.width(); + if (__w > __n) + { + const bool __left = ((__out.flags() + & __ios_base::adjustfield) + == __ios_base::left); + if (!__left) + __ostream_fill(__out, __w - __n); + if (__out.good()) + __ostream_write(__out, __s, __n); + if (__left && __out.good()) + __ostream_fill(__out, __w - __n); + } + else + __ostream_write(__out, __s, __n); + __out.width(0); + } + catch(__cxxabiv1::__forced_unwind&) + { + __out._M_setstate(__ios_base::badbit); + throw; + } + catch(...) + { __out._M_setstate(__ios_base::badbit); } + } + return __out; + } + + + + + extern template ostream& __ostream_insert(ostream&, const char*, streamsize); + + + extern template wostream& __ostream_insert(wostream&, const wchar_t*, + streamsize); + + + + +} +# 45 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 2 3 + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 1 3 +# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 104 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3 + template + struct unary_function + { + + typedef _Arg argument_type; + + + typedef _Result result_type; + }; + + + + + template + struct binary_function + { + + typedef _Arg1 first_argument_type; + + + typedef _Arg2 second_argument_type; + + + typedef _Result result_type; + }; +# 144 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3 + struct __is_transparent; + + template + struct plus; + + template + struct minus; + + template + struct multiplies; + + template + struct divides; + + template + struct modulus; + + template + struct negate; + + + + template + struct plus : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x + __y; } + }; + + + template + struct minus : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x - __y; } + }; + + + template + struct multiplies : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x * __y; } + }; + + + template + struct divides : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x / __y; } + }; + + + template + struct modulus : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x % __y; } + }; + + + template + struct negate : public unary_function<_Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x) const + { return -__x; } + }; + + + + + + template<> + struct plus + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct minus + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct multiplies + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct divides + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct modulus + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct negate + { + template + constexpr + auto + operator()(_Tp&& __t) const + noexcept(noexcept(-std::forward<_Tp>(__t))) + -> decltype(-std::forward<_Tp>(__t)) + { return -std::forward<_Tp>(__t); } + + typedef __is_transparent is_transparent; + }; +# 330 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3 + template + struct equal_to; + + template + struct not_equal_to; + + template + struct greater; + + template + struct less; + + template + struct greater_equal; + + template + struct less_equal; + + + + template + struct equal_to : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x == __y; } + }; + + + template + struct not_equal_to : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x != __y; } + }; + + + template + struct greater : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x > __y; } + }; + + + template + struct less : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x < __y; } + }; + + + template + struct greater_equal : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x >= __y; } + }; + + + template + struct less_equal : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x <= __y; } + }; + + + + template<> + struct equal_to + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct not_equal_to + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct greater + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct less + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct greater_equal + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct less_equal + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; +# 512 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3 + template + struct logical_and; + + template + struct logical_or; + + template + struct logical_not; + + + + template + struct logical_and : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x && __y; } + }; + + + template + struct logical_or : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x || __y; } + }; + + + template + struct logical_not : public unary_function<_Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x) const + { return !__x; } + }; + + + + template<> + struct logical_and + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct logical_or + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct logical_not + { + template + constexpr + auto + operator()(_Tp&& __t) const + noexcept(noexcept(!std::forward<_Tp>(__t))) + -> decltype(!std::forward<_Tp>(__t)) + { return !std::forward<_Tp>(__t); } + + typedef __is_transparent is_transparent; + }; + + + + + template + struct bit_and; + + template + struct bit_or; + + template + struct bit_xor; + + template + struct bit_not; + + + + + template + struct bit_and : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x & __y; } + }; + + template + struct bit_or : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x | __y; } + }; + + template + struct bit_xor : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x ^ __y; } + }; + + template + struct bit_not : public unary_function<_Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x) const + { return ~__x; } + }; + + + template <> + struct bit_and + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + template <> + struct bit_or + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + template <> + struct bit_xor + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + template <> + struct bit_not + { + template + constexpr + auto + operator()(_Tp&& __t) const + noexcept(noexcept(~std::forward<_Tp>(__t))) + -> decltype(~std::forward<_Tp>(__t)) + { return ~std::forward<_Tp>(__t); } + + typedef __is_transparent is_transparent; + }; +# 740 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3 + template + class unary_negate + : public unary_function + { + protected: + _Predicate _M_pred; + + public: + constexpr + explicit + unary_negate(const _Predicate& __x) : _M_pred(__x) { } + + constexpr + bool + operator()(const typename _Predicate::argument_type& __x) const + { return !_M_pred(__x); } + }; + + + template + constexpr + inline unary_negate<_Predicate> + not1(const _Predicate& __pred) + { return unary_negate<_Predicate>(__pred); } + + + template + class binary_negate + : public binary_function + { + protected: + _Predicate _M_pred; + + public: + constexpr + explicit + binary_negate(const _Predicate& __x) : _M_pred(__x) { } + + constexpr + bool + operator()(const typename _Predicate::first_argument_type& __x, + const typename _Predicate::second_argument_type& __y) const + { return !_M_pred(__x, __y); } + }; + + + template + constexpr + inline binary_negate<_Predicate> + not2(const _Predicate& __pred) + { return binary_negate<_Predicate>(__pred); } +# 817 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3 + template + class pointer_to_unary_function : public unary_function<_Arg, _Result> + { + protected: + _Result (*_M_ptr)(_Arg); + + public: + pointer_to_unary_function() { } + + explicit + pointer_to_unary_function(_Result (*__x)(_Arg)) + : _M_ptr(__x) { } + + _Result + operator()(_Arg __x) const + { return _M_ptr(__x); } + }; + + + template + inline pointer_to_unary_function<_Arg, _Result> + ptr_fun(_Result (*__x)(_Arg)) + { return pointer_to_unary_function<_Arg, _Result>(__x); } + + + template + class pointer_to_binary_function + : public binary_function<_Arg1, _Arg2, _Result> + { + protected: + _Result (*_M_ptr)(_Arg1, _Arg2); + + public: + pointer_to_binary_function() { } + + explicit + pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) + : _M_ptr(__x) { } + + _Result + operator()(_Arg1 __x, _Arg2 __y) const + { return _M_ptr(__x, __y); } + }; + + + template + inline pointer_to_binary_function<_Arg1, _Arg2, _Result> + ptr_fun(_Result (*__x)(_Arg1, _Arg2)) + { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } + + + template + struct _Identity + : public unary_function<_Tp,_Tp> + { + _Tp& + operator()(_Tp& __x) const + { return __x; } + + const _Tp& + operator()(const _Tp& __x) const + { return __x; } + }; + + template + struct _Select1st + : public unary_function<_Pair, typename _Pair::first_type> + { + typename _Pair::first_type& + operator()(_Pair& __x) const + { return __x.first; } + + const typename _Pair::first_type& + operator()(const _Pair& __x) const + { return __x.first; } + + + template + typename _Pair2::first_type& + operator()(_Pair2& __x) const + { return __x.first; } + + template + const typename _Pair2::first_type& + operator()(const _Pair2& __x) const + { return __x.first; } + + }; + + template + struct _Select2nd + : public unary_function<_Pair, typename _Pair::second_type> + { + typename _Pair::second_type& + operator()(_Pair& __x) const + { return __x.second; } + + const typename _Pair::second_type& + operator()(const _Pair& __x) const + { return __x.second; } + }; +# 937 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3 + template + class mem_fun_t : public unary_function<_Tp*, _Ret> + { + public: + explicit + mem_fun_t(_Ret (_Tp::*__pf)()) + : _M_f(__pf) { } + + _Ret + operator()(_Tp* __p) const + { return (__p->*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)(); + }; + + + + template + class const_mem_fun_t : public unary_function + { + public: + explicit + const_mem_fun_t(_Ret (_Tp::*__pf)() const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp* __p) const + { return (__p->*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)() const; + }; + + + + template + class mem_fun_ref_t : public unary_function<_Tp, _Ret> + { + public: + explicit + mem_fun_ref_t(_Ret (_Tp::*__pf)()) + : _M_f(__pf) { } + + _Ret + operator()(_Tp& __r) const + { return (__r.*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)(); + }; + + + + template + class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> + { + public: + explicit + const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp& __r) const + { return (__r.*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)() const; + }; + + + + template + class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> + { + public: + explicit + mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) + : _M_f(__pf) { } + + _Ret + operator()(_Tp* __p, _Arg __x) const + { return (__p->*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg); + }; + + + + template + class const_mem_fun1_t : public binary_function + { + public: + explicit + const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp* __p, _Arg __x) const + { return (__p->*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg) const; + }; + + + + template + class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> + { + public: + explicit + mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) + : _M_f(__pf) { } + + _Ret + operator()(_Tp& __r, _Arg __x) const + { return (__r.*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg); + }; + + + + template + class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> + { + public: + explicit + const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp& __r, _Arg __x) const + { return (__r.*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg) const; + }; + + + + template + inline mem_fun_t<_Ret, _Tp> + mem_fun(_Ret (_Tp::*__f)()) + { return mem_fun_t<_Ret, _Tp>(__f); } + + template + inline const_mem_fun_t<_Ret, _Tp> + mem_fun(_Ret (_Tp::*__f)() const) + { return const_mem_fun_t<_Ret, _Tp>(__f); } + + template + inline mem_fun_ref_t<_Ret, _Tp> + mem_fun_ref(_Ret (_Tp::*__f)()) + { return mem_fun_ref_t<_Ret, _Tp>(__f); } + + template + inline const_mem_fun_ref_t<_Ret, _Tp> + mem_fun_ref(_Ret (_Tp::*__f)() const) + { return const_mem_fun_ref_t<_Ret, _Tp>(__f); } + + template + inline mem_fun1_t<_Ret, _Tp, _Arg> + mem_fun(_Ret (_Tp::*__f)(_Arg)) + { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } + + template + inline const_mem_fun1_t<_Ret, _Tp, _Arg> + mem_fun(_Ret (_Tp::*__f)(_Arg) const) + { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } + + template + inline mem_fun1_ref_t<_Ret, _Tp, _Arg> + mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) + { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } + + template + inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> + mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) + { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } + + + + +} + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/backward/binders.h" 1 3 +# 60 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/backward/binders.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 107 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/backward/binders.h" 3 + template + class binder1st + : public unary_function + { + protected: + _Operation op; + typename _Operation::first_argument_type value; + + public: + binder1st(const _Operation& __x, + const typename _Operation::first_argument_type& __y) + : op(__x), value(__y) { } + + typename _Operation::result_type + operator()(const typename _Operation::second_argument_type& __x) const + { return op(value, __x); } + + + + typename _Operation::result_type + operator()(typename _Operation::second_argument_type& __x) const + { return op(value, __x); } + } __attribute__ ((__deprecated__)); + + + template + inline binder1st<_Operation> + bind1st(const _Operation& __fn, const _Tp& __x) + { + typedef typename _Operation::first_argument_type _Arg1_type; + return binder1st<_Operation>(__fn, _Arg1_type(__x)); + } + + + template + class binder2nd + : public unary_function + { + protected: + _Operation op; + typename _Operation::second_argument_type value; + + public: + binder2nd(const _Operation& __x, + const typename _Operation::second_argument_type& __y) + : op(__x), value(__y) { } + + typename _Operation::result_type + operator()(const typename _Operation::first_argument_type& __x) const + { return op(__x, value); } + + + + typename _Operation::result_type + operator()(typename _Operation::first_argument_type& __x) const + { return op(__x, value); } + } __attribute__ ((__deprecated__)); + + + template + inline binder2nd<_Operation> + bind2nd(const _Operation& __fn, const _Tp& __x) + { + typedef typename _Operation::second_argument_type _Arg2_type; + return binder2nd<_Operation>(__fn, _Arg2_type(__x)); + } + + + +} + +#pragma GCC diagnostic pop +# 1128 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 2 3 +# 49 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/range_access.h" 1 3 +# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/range_access.h" 3 + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/initializer_list" 1 3 +# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/initializer_list" 3 + + + + + +#pragma GCC visibility push(default) + + + +namespace std +{ + + template + class initializer_list + { + public: + typedef _E value_type; + typedef const _E& reference; + typedef const _E& const_reference; + typedef size_t size_type; + typedef const _E* iterator; + typedef const _E* const_iterator; + + private: + iterator _M_array; + size_type _M_len; + + + constexpr initializer_list(const_iterator __a, size_type __l) + : _M_array(__a), _M_len(__l) { } + + public: + constexpr initializer_list() noexcept + : _M_array(0), _M_len(0) { } + + + constexpr size_type + size() const noexcept { return _M_len; } + + + constexpr const_iterator + begin() const noexcept { return _M_array; } + + + constexpr const_iterator + end() const noexcept { return begin() + size(); } + }; + + + + + + + template + constexpr const _Tp* + begin(initializer_list<_Tp> __ils) noexcept + { return __ils.begin(); } + + + + + + + template + constexpr const _Tp* + end(initializer_list<_Tp> __ils) noexcept + { return __ils.end(); } +} + +#pragma GCC visibility pop +# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/range_access.h" 2 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + inline auto + begin(_Container& __cont) -> decltype(__cont.begin()) + { return __cont.begin(); } + + + + + + + template + inline auto + begin(const _Container& __cont) -> decltype(__cont.begin()) + { return __cont.begin(); } + + + + + + + template + inline auto + end(_Container& __cont) -> decltype(__cont.end()) + { return __cont.end(); } + + + + + + + template + inline auto + end(const _Container& __cont) -> decltype(__cont.end()) + { return __cont.end(); } + + + + + + template + inline constexpr _Tp* + begin(_Tp (&__arr)[_Nm]) + { return __arr; } + + + + + + + template + inline constexpr _Tp* + end(_Tp (&__arr)[_Nm]) + { return __arr + _Nm; } + + + + template class valarray; + + template _Tp* begin(valarray<_Tp>&); + template const _Tp* begin(const valarray<_Tp>&); + template _Tp* end(valarray<_Tp>&); + template const _Tp* end(const valarray<_Tp>&); + + + + + + + template + inline constexpr auto + cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont))) + -> decltype(std::begin(__cont)) + { return std::begin(__cont); } + + + + + + + template + inline constexpr auto + cend(const _Container& __cont) noexcept(noexcept(std::end(__cont))) + -> decltype(std::end(__cont)) + { return std::end(__cont); } + + + + + + + template + inline auto + rbegin(_Container& __cont) -> decltype(__cont.rbegin()) + { return __cont.rbegin(); } + + + + + + + template + inline auto + rbegin(const _Container& __cont) -> decltype(__cont.rbegin()) + { return __cont.rbegin(); } + + + + + + + template + inline auto + rend(_Container& __cont) -> decltype(__cont.rend()) + { return __cont.rend(); } + + + + + + + template + inline auto + rend(const _Container& __cont) -> decltype(__cont.rend()) + { return __cont.rend(); } + + + + + + + template + inline reverse_iterator<_Tp*> + rbegin(_Tp (&__arr)[_Nm]) + { return reverse_iterator<_Tp*>(__arr + _Nm); } + + + + + + + template + inline reverse_iterator<_Tp*> + rend(_Tp (&__arr)[_Nm]) + { return reverse_iterator<_Tp*>(__arr); } + + + + + + + template + inline reverse_iterator + rbegin(initializer_list<_Tp> __il) + { return reverse_iterator(__il.end()); } + + + + + + + template + inline reverse_iterator + rend(initializer_list<_Tp> __il) + { return reverse_iterator(__il.begin()); } + + + + + + + template + inline auto + crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont)) + { return std::rbegin(__cont); } + + + + + + + template + inline auto + crend(const _Container& __cont) -> decltype(std::rend(__cont)) + { return std::rend(__cont); } +# 320 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/range_access.h" 3 +} +# 52 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 1 3 +# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/alloc_traits.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/alloc_traits.h" 3 + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 1 3 +# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + struct __allocator_traits_base + { + template + using __rebind = typename _Alloc::template rebind<_Up>::other; + + protected: + template + using __pointer = typename _Tp::pointer; + template + using __c_pointer = typename _Tp::const_pointer; + template + using __v_pointer = typename _Tp::void_pointer; + template + using __cv_pointer = typename _Tp::const_void_pointer; + template + using __diff_type = typename _Tp::difference_type; + template + using __size_type = typename _Tp::size_type; + template + using __pocca = typename _Tp::propagate_on_container_copy_assignment; + template + using __pocma = typename _Tp::propagate_on_container_move_assignment; + template + using __pocs = typename _Tp::propagate_on_container_swap; + template + using __equal = typename _Tp::is_always_equal; + }; + + template + using __alloc_rebind = __detected_or_t_<__replace_first_arg_t, + __allocator_traits_base::__rebind, + _Alloc, _Up>; + + + + + + template + struct allocator_traits : __allocator_traits_base + { + + typedef _Alloc allocator_type; + + typedef typename _Alloc::value_type value_type; + + + + + + + using pointer = __detected_or_t; + + + + + + + + using const_pointer + = __detected_or_t<__ptr_rebind, + __c_pointer, _Alloc>; + + + + + + + + using void_pointer + = __detected_or_t<__ptr_rebind, __v_pointer, _Alloc>; + + + + + + + + using const_void_pointer + = __detected_or_t<__ptr_rebind, __cv_pointer, + _Alloc>; + + + + + + + + using difference_type + = __detected_or_t::difference_type, + __diff_type, _Alloc>; + + + + + + + + using size_type + = __detected_or_t::type, + __size_type, _Alloc>; + + + + + + + + using propagate_on_container_copy_assignment + = __detected_or_t; + + + + + + + + using propagate_on_container_move_assignment + = __detected_or_t; + + + + + + + + using propagate_on_container_swap + = __detected_or_t; + + + + + + + + using is_always_equal + = __detected_or_t::type, __equal, _Alloc>; + + template + using rebind_alloc = __alloc_rebind<_Alloc, _Tp>; + template + using rebind_traits = allocator_traits>; + + static_assert(!is_same, __undefined>::value, + "allocator defines rebind or is like Alloc"); + + private: + template + static auto + _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int) + -> decltype(__a.allocate(__n, __hint)) + { return __a.allocate(__n, __hint); } + + template + static pointer + _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...) + { return __a.allocate(__n); } + + template + struct __construct_helper + { + template()->construct( + std::declval<_Tp*>(), std::declval<_Args>()...))> + static true_type __test(int); + + template + static false_type __test(...); + + using type = decltype(__test<_Alloc>(0)); + }; + + template + using __has_construct + = typename __construct_helper<_Tp, _Args...>::type; + + template + static _Require<__has_construct<_Tp, _Args...>> + _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args) + { __a.construct(__p, std::forward<_Args>(__args)...); } + + template + static + _Require<__and_<__not_<__has_construct<_Tp, _Args...>>, + is_constructible<_Tp, _Args...>>> + _S_construct(_Alloc&, _Tp* __p, _Args&&... __args) + { ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); } + + template + static auto + _S_destroy(_Alloc2& __a, _Tp* __p, int) + -> decltype(__a.destroy(__p)) + { __a.destroy(__p); } + + template + static void + _S_destroy(_Alloc2&, _Tp* __p, ...) + { __p->~_Tp(); } + + template + static auto + _S_max_size(_Alloc2& __a, int) + -> decltype(__a.max_size()) + { return __a.max_size(); } + + template + static size_type + _S_max_size(_Alloc2&, ...) + { + + + return __gnu_cxx::__numeric_traits::__max + / sizeof(value_type); + } + + template + static auto + _S_select(_Alloc2& __a, int) + -> decltype(__a.select_on_container_copy_construction()) + { return __a.select_on_container_copy_construction(); } + + template + static _Alloc2 + _S_select(_Alloc2& __a, ...) + { return __a; } + + public: +# 279 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3 + static pointer + allocate(_Alloc& __a, size_type __n) + { return __a.allocate(__n); } +# 294 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3 + static pointer + allocate(_Alloc& __a, size_type __n, const_void_pointer __hint) + { return _S_allocate(__a, __n, __hint, 0); } +# 306 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3 + static void + deallocate(_Alloc& __a, pointer __p, size_type __n) + { __a.deallocate(__p, __n); } +# 321 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3 + template + static auto construct(_Alloc& __a, _Tp* __p, _Args&&... __args) + -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...)) + { _S_construct(__a, __p, std::forward<_Args>(__args)...); } +# 334 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3 + template + static void destroy(_Alloc& __a, _Tp* __p) + { _S_destroy(__a, __p, 0); } +# 346 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3 + static size_type max_size(const _Alloc& __a) noexcept + { return _S_max_size(__a, 0); } +# 357 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3 + static _Alloc + select_on_container_copy_construction(const _Alloc& __rhs) + { return _S_select(__rhs, 0); } + }; + + + template + struct allocator_traits> + { + + using allocator_type = allocator<_Tp>; + + using value_type = _Tp; + + + using pointer = _Tp*; + + + using const_pointer = const _Tp*; + + + using void_pointer = void*; + + + using const_void_pointer = const void*; + + + using difference_type = std::ptrdiff_t; + + + using size_type = std::size_t; + + + using propagate_on_container_copy_assignment = false_type; + + + using propagate_on_container_move_assignment = true_type; + + + using propagate_on_container_swap = false_type; + + + using is_always_equal = true_type; + + template + using rebind_alloc = allocator<_Up>; + + template + using rebind_traits = allocator_traits>; +# 414 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3 + static pointer + allocate(allocator_type& __a, size_type __n) + { return __a.allocate(__n); } +# 428 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3 + static pointer + allocate(allocator_type& __a, size_type __n, const_void_pointer __hint) + { return __a.allocate(__n, __hint); } +# 440 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3 + static void + deallocate(allocator_type& __a, pointer __p, size_type __n) + { __a.deallocate(__p, __n); } +# 452 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3 + template + static void + construct(allocator_type& __a, _Up* __p, _Args&&... __args) + { __a.construct(__p, std::forward<_Args>(__args)...); } +# 464 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3 + template + static void + destroy(allocator_type& __a, _Up* __p) + { __a.destroy(__p); } + + + + + + + static size_type + max_size(const allocator_type& __a) noexcept + { return __a.max_size(); } + + + + + + + static allocator_type + select_on_container_copy_construction(const allocator_type& __rhs) + { return __rhs; } + }; + + + template + inline void + __do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type) + { __one = __two; } + + template + inline void + __do_alloc_on_copy(_Alloc&, const _Alloc&, false_type) + { } + + template + inline void __alloc_on_copy(_Alloc& __one, const _Alloc& __two) + { + typedef allocator_traits<_Alloc> __traits; + typedef typename __traits::propagate_on_container_copy_assignment __pocca; + __do_alloc_on_copy(__one, __two, __pocca()); + } + + template + inline _Alloc __alloc_on_copy(const _Alloc& __a) + { + typedef allocator_traits<_Alloc> __traits; + return __traits::select_on_container_copy_construction(__a); + } + + template + inline void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type) + { __one = std::move(__two); } + + template + inline void __do_alloc_on_move(_Alloc&, _Alloc&, false_type) + { } + + template + inline void __alloc_on_move(_Alloc& __one, _Alloc& __two) + { + typedef allocator_traits<_Alloc> __traits; + typedef typename __traits::propagate_on_container_move_assignment __pocma; + __do_alloc_on_move(__one, __two, __pocma()); + } + + template + inline void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type) + { + using std::swap; + swap(__one, __two); + } + + template + inline void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type) + { } + + template + inline void __alloc_on_swap(_Alloc& __one, _Alloc& __two) + { + typedef allocator_traits<_Alloc> __traits; + typedef typename __traits::propagate_on_container_swap __pocs; + __do_alloc_on_swap(__one, __two, __pocs()); + } + + template + class __is_copy_insertable_impl + { + typedef allocator_traits<_Alloc> _Traits; + + template(), + std::declval<_Up*>(), + std::declval()))> + static true_type + _M_select(int); + + template + static false_type + _M_select(...); + + public: + typedef decltype(_M_select(0)) type; + }; + + + template + struct __is_copy_insertable + : __is_copy_insertable_impl<_Alloc>::type + { }; + + + template + struct __is_copy_insertable> + : is_copy_constructible<_Tp> + { }; + + +} +# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/alloc_traits.h" 2 3 + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + + + +template + struct __alloc_traits + + : std::allocator_traits<_Alloc> + + { + typedef _Alloc allocator_type; + + typedef std::allocator_traits<_Alloc> _Base_type; + typedef typename _Base_type::value_type value_type; + typedef typename _Base_type::pointer pointer; + typedef typename _Base_type::const_pointer const_pointer; + typedef typename _Base_type::size_type size_type; + typedef typename _Base_type::difference_type difference_type; + + typedef value_type& reference; + typedef const value_type& const_reference; + using _Base_type::allocate; + using _Base_type::deallocate; + using _Base_type::construct; + using _Base_type::destroy; + using _Base_type::max_size; + + private: + template + using __is_custom_pointer + = std::__and_, + std::__not_>>; + + public: + + template + static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type + construct(_Alloc& __a, _Ptr __p, _Args&&... __args) + { + _Base_type::construct(__a, std::addressof(*__p), + std::forward<_Args>(__args)...); + } + + + template + static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type + destroy(_Alloc& __a, _Ptr __p) + { _Base_type::destroy(__a, std::addressof(*__p)); } + + static _Alloc _S_select_on_copy(const _Alloc& __a) + { return _Base_type::select_on_container_copy_construction(__a); } + + static void _S_on_swap(_Alloc& __a, _Alloc& __b) + { std::__alloc_on_swap(__a, __b); } + + static constexpr bool _S_propagate_on_copy_assign() + { return _Base_type::propagate_on_container_copy_assignment::value; } + + static constexpr bool _S_propagate_on_move_assign() + { return _Base_type::propagate_on_container_move_assignment::value; } + + static constexpr bool _S_propagate_on_swap() + { return _Base_type::propagate_on_container_swap::value; } + + static constexpr bool _S_always_equal() + { return _Base_type::is_always_equal::value; } + + static constexpr bool _S_nothrow_move() + { return _S_propagate_on_move_assign() || _S_always_equal(); } + + template + struct rebind + { typedef typename _Base_type::template rebind_alloc<_Tp> other; }; +# 158 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/alloc_traits.h" 3 + }; + + +} +# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 2 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + +namespace __cxx11 { +# 71 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + template + class basic_string + { + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind<_CharT>::other _Char_alloc_type; + typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits; + + + public: + typedef _Traits traits_type; + typedef typename _Traits::char_type value_type; + typedef _Char_alloc_type allocator_type; + typedef typename _Alloc_traits::size_type size_type; + typedef typename _Alloc_traits::difference_type difference_type; + typedef typename _Alloc_traits::reference reference; + typedef typename _Alloc_traits::const_reference const_reference; + typedef typename _Alloc_traits::pointer pointer; + typedef typename _Alloc_traits::const_pointer const_pointer; + typedef __gnu_cxx::__normal_iterator iterator; + typedef __gnu_cxx::__normal_iterator + const_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + + + static const size_type npos = static_cast(-1); + + private: + + + + + typedef const_iterator __const_iterator; + + + + struct _Alloc_hider : allocator_type + { + _Alloc_hider(pointer __dat, const _Alloc& __a = _Alloc()) + : allocator_type(__a), _M_p(__dat) { } + + pointer _M_p; + }; + + _Alloc_hider _M_dataplus; + size_type _M_string_length; + + enum { _S_local_capacity = 15 / sizeof(_CharT) }; + + union + { + _CharT _M_local_buf[_S_local_capacity + 1]; + size_type _M_allocated_capacity; + }; + + void + _M_data(pointer __p) + { _M_dataplus._M_p = __p; } + + void + _M_length(size_type __length) + { _M_string_length = __length; } + + pointer + _M_data() const + { return _M_dataplus._M_p; } + + pointer + _M_local_data() + { + + return std::pointer_traits::pointer_to(*_M_local_buf); + + + + } + + const_pointer + _M_local_data() const + { + + return std::pointer_traits::pointer_to(*_M_local_buf); + + + + } + + void + _M_capacity(size_type __capacity) + { _M_allocated_capacity = __capacity; } + + void + _M_set_length(size_type __n) + { + _M_length(__n); + traits_type::assign(_M_data()[__n], _CharT()); + } + + bool + _M_is_local() const + { return _M_data() == _M_local_data(); } + + + pointer + _M_create(size_type&, size_type); + + void + _M_dispose() + { + if (!_M_is_local()) + _M_destroy(_M_allocated_capacity); + } + + void + _M_destroy(size_type __size) throw() + { _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); } + + + + template + void + _M_construct_aux(_InIterator __beg, _InIterator __end, + std::__false_type) + { + typedef typename iterator_traits<_InIterator>::iterator_category _Tag; + _M_construct(__beg, __end, _Tag()); + } + + + + template + void + _M_construct_aux(_Integer __beg, _Integer __end, std::__true_type) + { _M_construct_aux_2(static_cast(__beg), __end); } + + void + _M_construct_aux_2(size_type __req, _CharT __c) + { _M_construct(__req, __c); } + + template + void + _M_construct(_InIterator __beg, _InIterator __end) + { + typedef typename std::__is_integer<_InIterator>::__type _Integral; + _M_construct_aux(__beg, __end, _Integral()); + } + + + template + void + _M_construct(_InIterator __beg, _InIterator __end, + std::input_iterator_tag); + + + + template + void + _M_construct(_FwdIterator __beg, _FwdIterator __end, + std::forward_iterator_tag); + + void + _M_construct(size_type __req, _CharT __c); + + allocator_type& + _M_get_allocator() + { return _M_dataplus; } + + const allocator_type& + _M_get_allocator() const + { return _M_dataplus; } + + private: +# 258 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + _M_check(size_type __pos, const char* __s) const + { + if (__pos > this->size()) + __throw_out_of_range_fmt(("%s: __pos (which is %zu) > " "this->size() (which is %zu)"), + + __s, __pos, this->size()); + return __pos; + } + + void + _M_check_length(size_type __n1, size_type __n2, const char* __s) const + { + if (this->max_size() - (this->size() - __n1) < __n2) + __throw_length_error((__s)); + } + + + + size_type + _M_limit(size_type __pos, size_type __off) const noexcept + { + const bool __testoff = __off < this->size() - __pos; + return __testoff ? __off : this->size() - __pos; + } + + + bool + _M_disjunct(const _CharT* __s) const noexcept + { + return (less()(__s, _M_data()) + || less()(_M_data() + this->size(), __s)); + } + + + + static void + _S_copy(_CharT* __d, const _CharT* __s, size_type __n) + { + if (__n == 1) + traits_type::assign(*__d, *__s); + else + traits_type::copy(__d, __s, __n); + } + + static void + _S_move(_CharT* __d, const _CharT* __s, size_type __n) + { + if (__n == 1) + traits_type::assign(*__d, *__s); + else + traits_type::move(__d, __s, __n); + } + + static void + _S_assign(_CharT* __d, size_type __n, _CharT __c) + { + if (__n == 1) + traits_type::assign(*__d, __c); + else + traits_type::assign(__d, __n, __c); + } + + + + template + static void + _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2) + { + for (; __k1 != __k2; ++__k1, (void)++__p) + traits_type::assign(*__p, *__k1); + } + + static void + _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) noexcept + { _S_copy_chars(__p, __k1.base(), __k2.base()); } + + static void + _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2) + noexcept + { _S_copy_chars(__p, __k1.base(), __k2.base()); } + + static void + _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) noexcept + { _S_copy(__p, __k1, __k2 - __k1); } + + static void + _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2) + noexcept + { _S_copy(__p, __k1, __k2 - __k1); } + + static int + _S_compare(size_type __n1, size_type __n2) noexcept + { + const difference_type __d = difference_type(__n1 - __n2); + + if (__d > __gnu_cxx::__numeric_traits::__max) + return __gnu_cxx::__numeric_traits::__max; + else if (__d < __gnu_cxx::__numeric_traits::__min) + return __gnu_cxx::__numeric_traits::__min; + else + return int(__d); + } + + void + _M_assign(const basic_string& __rcs); + + void + _M_mutate(size_type __pos, size_type __len1, const _CharT* __s, + size_type __len2); + + void + _M_erase(size_type __pos, size_type __n); + + public: + + + + + + + + basic_string() + noexcept(is_nothrow_default_constructible<_Alloc>::value) + : _M_dataplus(_M_local_data()) + { _M_set_length(0); } + + + + + explicit + basic_string(const _Alloc& __a) noexcept + : _M_dataplus(_M_local_data(), __a) + { _M_set_length(0); } + + + + + + basic_string(const basic_string& __str) + : _M_dataplus(_M_local_data(), + _Alloc_traits::_S_select_on_copy(__str._M_get_allocator())) + { _M_construct(__str._M_data(), __str._M_data() + __str.length()); } +# 410 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string(const basic_string& __str, size_type __pos, + size_type __n = npos) + : _M_dataplus(_M_local_data()) + { + const _CharT* __start = __str._M_data() + + __str._M_check(__pos, "basic_string::basic_string"); + _M_construct(__start, __start + __str._M_limit(__pos, __n)); + } +# 426 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string(const basic_string& __str, size_type __pos, + size_type __n, const _Alloc& __a) + : _M_dataplus(_M_local_data(), __a) + { + const _CharT* __start + = __str._M_data() + __str._M_check(__pos, "string::string"); + _M_construct(__start, __start + __str._M_limit(__pos, __n)); + } +# 444 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string(const _CharT* __s, size_type __n, + const _Alloc& __a = _Alloc()) + : _M_dataplus(_M_local_data(), __a) + { _M_construct(__s, __s + __n); } + + + + + + + basic_string(const _CharT* __s, const _Alloc& __a = _Alloc()) + : _M_dataplus(_M_local_data(), __a) + { _M_construct(__s, __s ? __s + traits_type::length(__s) : __s+npos); } + + + + + + + + basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc()) + : _M_dataplus(_M_local_data(), __a) + { _M_construct(__n, __c); } +# 476 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string(basic_string&& __str) noexcept + : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator())) + { + if (__str._M_is_local()) + { + traits_type::copy(_M_local_buf, __str._M_local_buf, + _S_local_capacity + 1); + } + else + { + _M_data(__str._M_data()); + _M_capacity(__str._M_allocated_capacity); + } + + + + + _M_length(__str.length()); + __str._M_data(__str._M_local_data()); + __str._M_set_length(0); + } + + + + + + + basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc()) + : _M_dataplus(_M_local_data(), __a) + { _M_construct(__l.begin(), __l.end()); } + + basic_string(const basic_string& __str, const _Alloc& __a) + : _M_dataplus(_M_local_data(), __a) + { _M_construct(__str.begin(), __str.end()); } + + basic_string(basic_string&& __str, const _Alloc& __a) + noexcept(_Alloc_traits::_S_always_equal()) + : _M_dataplus(_M_local_data(), __a) + { + if (__str._M_is_local()) + { + traits_type::copy(_M_local_buf, __str._M_local_buf, + _S_local_capacity + 1); + _M_length(__str.length()); + __str._M_set_length(0); + } + else if (_Alloc_traits::_S_always_equal() + || __str.get_allocator() == __a) + { + _M_data(__str._M_data()); + _M_length(__str.length()); + _M_capacity(__str._M_allocated_capacity); + __str._M_data(__str._M_local_buf); + __str._M_set_length(0); + } + else + _M_construct(__str.begin(), __str.end()); + } +# 544 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + template> + + + + basic_string(_InputIterator __beg, _InputIterator __end, + const _Alloc& __a = _Alloc()) + : _M_dataplus(_M_local_data(), __a) + { _M_construct(__beg, __end); } + + + + + ~basic_string() + { _M_dispose(); } + + + + + + basic_string& + operator=(const basic_string& __str) + { + + if (_Alloc_traits::_S_propagate_on_copy_assign()) + { + if (!_Alloc_traits::_S_always_equal() && !_M_is_local() + && _M_get_allocator() != __str._M_get_allocator()) + { + + _M_destroy(_M_allocated_capacity); + _M_data(_M_local_data()); + _M_set_length(0); + } + std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator()); + } + + return this->assign(__str); + } + + + + + + basic_string& + operator=(const _CharT* __s) + { return this->assign(__s); } +# 599 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + operator=(_CharT __c) + { + this->assign(1, __c); + return *this; + } +# 617 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + operator=(basic_string&& __str) + noexcept(_Alloc_traits::_S_nothrow_move()) + { + if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign() + && !_Alloc_traits::_S_always_equal() + && _M_get_allocator() != __str._M_get_allocator()) + { + + _M_destroy(_M_allocated_capacity); + _M_data(_M_local_data()); + _M_set_length(0); + } + + std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator()); + + if (!__str._M_is_local() + && (_Alloc_traits::_S_propagate_on_move_assign() + || _Alloc_traits::_S_always_equal())) + { + pointer __data = nullptr; + size_type __capacity; + if (!_M_is_local()) + { + if (_Alloc_traits::_S_always_equal()) + { + __data = _M_data(); + __capacity = _M_allocated_capacity; + } + else + _M_destroy(_M_allocated_capacity); + } + + _M_data(__str._M_data()); + _M_length(__str.length()); + _M_capacity(__str._M_allocated_capacity); + if (__data) + { + __str._M_data(__data); + __str._M_capacity(__capacity); + } + else + __str._M_data(__str._M_local_buf); + } + else + assign(__str); + __str.clear(); + return *this; + } + + + + + + basic_string& + operator=(initializer_list<_CharT> __l) + { + this->assign(__l.begin(), __l.size()); + return *this; + } + + + + + + + + iterator + begin() noexcept + { return iterator(_M_data()); } + + + + + + const_iterator + begin() const noexcept + { return const_iterator(_M_data()); } + + + + + + iterator + end() noexcept + { return iterator(_M_data() + this->size()); } + + + + + + const_iterator + end() const noexcept + { return const_iterator(_M_data() + this->size()); } + + + + + + + reverse_iterator + rbegin() noexcept + { return reverse_iterator(this->end()); } + + + + + + + const_reverse_iterator + rbegin() const noexcept + { return const_reverse_iterator(this->end()); } + + + + + + + reverse_iterator + rend() noexcept + { return reverse_iterator(this->begin()); } + + + + + + + const_reverse_iterator + rend() const noexcept + { return const_reverse_iterator(this->begin()); } + + + + + + + const_iterator + cbegin() const noexcept + { return const_iterator(this->_M_data()); } + + + + + + const_iterator + cend() const noexcept + { return const_iterator(this->_M_data() + this->size()); } + + + + + + + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(this->end()); } + + + + + + + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(this->begin()); } + + + public: + + + + size_type + size() const noexcept + { return _M_string_length; } + + + + size_type + length() const noexcept + { return _M_string_length; } + + + size_type + max_size() const noexcept + { return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; } +# 813 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + void + resize(size_type __n, _CharT __c); +# 826 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + void + resize(size_type __n) + { this->resize(__n, _CharT()); } + + + + void + shrink_to_fit() noexcept + { + + if (capacity() > size()) + { + try + { reserve(0); } + catch(...) + { } + } + + } + + + + + + + size_type + capacity() const noexcept + { + return _M_is_local() ? size_type(_S_local_capacity) + : _M_allocated_capacity; + } +# 875 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + void + reserve(size_type __res_arg = 0); + + + + + void + clear() noexcept + { _M_set_length(0); } + + + + + + bool + empty() const noexcept + { return this->size() == 0; } +# 904 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + const_reference + operator[] (size_type __pos) const noexcept + { + ; + return _M_data()[__pos]; + } +# 921 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + reference + operator[](size_type __pos) + { + + + ; + + ; + return _M_data()[__pos]; + } +# 942 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + const_reference + at(size_type __n) const + { + if (__n >= this->size()) + __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)"), + + + __n, this->size()); + return _M_data()[__n]; + } +# 963 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + reference + at(size_type __n) + { + if (__n >= size()) + __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)"), + + + __n, this->size()); + return _M_data()[__n]; + } + + + + + + + reference + front() noexcept + { + ; + return operator[](0); + } + + + + + + const_reference + front() const noexcept + { + ; + return operator[](0); + } + + + + + + reference + back() noexcept + { + ; + return operator[](this->size() - 1); + } + + + + + + const_reference + back() const noexcept + { + ; + return operator[](this->size() - 1); + } +# 1026 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + operator+=(const basic_string& __str) + { return this->append(__str); } + + + + + + + basic_string& + operator+=(const _CharT* __s) + { return this->append(__s); } + + + + + + + basic_string& + operator+=(_CharT __c) + { + this->push_back(__c); + return *this; + } + + + + + + + + basic_string& + operator+=(initializer_list<_CharT> __l) + { return this->append(__l.begin(), __l.size()); } + + + + + + + + basic_string& + append(const basic_string& __str) + { return _M_append(__str._M_data(), __str.size()); } +# 1084 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + append(const basic_string& __str, size_type __pos, size_type __n) + { return _M_append(__str._M_data() + + __str._M_check(__pos, "basic_string::append"), + __str._M_limit(__pos, __n)); } + + + + + + + + basic_string& + append(const _CharT* __s, size_type __n) + { + ; + _M_check_length(size_type(0), __n, "basic_string::append"); + return _M_append(__s, __n); + } + + + + + + + basic_string& + append(const _CharT* __s) + { + ; + const size_type __n = traits_type::length(__s); + _M_check_length(size_type(0), __n, "basic_string::append"); + return _M_append(__s, __n); + } +# 1126 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + append(size_type __n, _CharT __c) + { return _M_replace_aux(this->size(), size_type(0), __n, __c); } + + + + + + + + basic_string& + append(initializer_list<_CharT> __l) + { return this->append(__l.begin(), __l.size()); } +# 1150 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + template> + + + + basic_string& + append(_InputIterator __first, _InputIterator __last) + { return this->replace(end(), end(), __first, __last); } + + + + + + void + push_back(_CharT __c) + { + const size_type __size = this->size(); + if (__size + 1 > this->capacity()) + this->_M_mutate(__size, size_type(0), 0, size_type(1)); + traits_type::assign(this->_M_data()[__size], __c); + this->_M_set_length(__size + 1); + } + + + + + + + basic_string& + assign(const basic_string& __str) + { + this->_M_assign(__str); + return *this; + } +# 1194 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + assign(basic_string&& __str) + noexcept(_Alloc_traits::_S_nothrow_move()) + { + + + return *this = std::move(__str); + } +# 1217 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + assign(const basic_string& __str, size_type __pos, size_type __n) + { return _M_replace(size_type(0), this->size(), __str._M_data() + + __str._M_check(__pos, "basic_string::assign"), + __str._M_limit(__pos, __n)); } +# 1233 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + assign(const _CharT* __s, size_type __n) + { + ; + return _M_replace(size_type(0), this->size(), __s, __n); + } +# 1249 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + assign(const _CharT* __s) + { + ; + return _M_replace(size_type(0), this->size(), __s, + traits_type::length(__s)); + } +# 1266 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + assign(size_type __n, _CharT __c) + { return _M_replace_aux(size_type(0), this->size(), __n, __c); } +# 1279 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + template> + + + + basic_string& + assign(_InputIterator __first, _InputIterator __last) + { return this->replace(begin(), end(), __first, __last); } + + + + + + + + basic_string& + assign(initializer_list<_CharT> __l) + { return this->assign(__l.begin(), __l.size()); } +# 1315 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + iterator + insert(const_iterator __p, size_type __n, _CharT __c) + { + ; + const size_type __pos = __p - begin(); + this->replace(__p, __p, __n, __c); + return iterator(this->_M_data() + __pos); + } +# 1357 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + template> + iterator + insert(const_iterator __p, _InputIterator __beg, _InputIterator __end) + { + ; + const size_type __pos = __p - begin(); + this->replace(__p, __p, __beg, __end); + return iterator(this->_M_data() + __pos); + } +# 1393 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + void + insert(iterator __p, initializer_list<_CharT> __l) + { + ; + this->insert(__p - begin(), __l.begin(), __l.size()); + } +# 1413 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + insert(size_type __pos1, const basic_string& __str) + { return this->replace(__pos1, size_type(0), + __str._M_data(), __str.size()); } +# 1436 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + insert(size_type __pos1, const basic_string& __str, + size_type __pos2, size_type __n) + { return this->replace(__pos1, size_type(0), __str._M_data() + + __str._M_check(__pos2, "basic_string::insert"), + __str._M_limit(__pos2, __n)); } +# 1459 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + insert(size_type __pos, const _CharT* __s, size_type __n) + { return this->replace(__pos, size_type(0), __s, __n); } +# 1478 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + insert(size_type __pos, const _CharT* __s) + { + ; + return this->replace(__pos, size_type(0), __s, + traits_type::length(__s)); + } +# 1502 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + insert(size_type __pos, size_type __n, _CharT __c) + { return _M_replace_aux(_M_check(__pos, "basic_string::insert"), + size_type(0), __n, __c); } +# 1520 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + iterator + insert(__const_iterator __p, _CharT __c) + { + ; + const size_type __pos = __p - begin(); + _M_replace_aux(__pos, size_type(0), size_type(1), __c); + return iterator(_M_data() + __pos); + } +# 1544 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + erase(size_type __pos = 0, size_type __n = npos) + { + this->_M_erase(_M_check(__pos, "basic_string::erase"), + _M_limit(__pos, __n)); + return *this; + } +# 1560 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + iterator + erase(__const_iterator __position) + { + + ; + const size_type __pos = __position - begin(); + this->_M_erase(__pos, size_type(1)); + return iterator(_M_data() + __pos); + } +# 1579 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + iterator + erase(__const_iterator __first, __const_iterator __last) + { + + ; + const size_type __pos = __first - begin(); + this->_M_erase(__pos, __last - __first); + return iterator(this->_M_data() + __pos); + } + + + + + + + + void + pop_back() noexcept + { + ; + _M_erase(size() - 1, 1); + } +# 1620 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + replace(size_type __pos, size_type __n, const basic_string& __str) + { return this->replace(__pos, __n, __str._M_data(), __str.size()); } +# 1642 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + replace(size_type __pos1, size_type __n1, const basic_string& __str, + size_type __pos2, size_type __n2) + { return this->replace(__pos1, __n1, __str._M_data() + + __str._M_check(__pos2, "basic_string::replace"), + __str._M_limit(__pos2, __n2)); } +# 1667 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + replace(size_type __pos, size_type __n1, const _CharT* __s, + size_type __n2) + { + ; + return _M_replace(_M_check(__pos, "basic_string::replace"), + _M_limit(__pos, __n1), __s, __n2); + } +# 1692 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + replace(size_type __pos, size_type __n1, const _CharT* __s) + { + ; + return this->replace(__pos, __n1, __s, traits_type::length(__s)); + } +# 1716 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c) + { return _M_replace_aux(_M_check(__pos, "basic_string::replace"), + _M_limit(__pos, __n1), __n2, __c); } +# 1734 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, + const basic_string& __str) + { return this->replace(__i1, __i2, __str._M_data(), __str.size()); } +# 1754 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, + const _CharT* __s, size_type __n) + { + + ; + return this->replace(__i1 - begin(), __i2 - __i1, __s, __n); + } +# 1776 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s) + { + ; + return this->replace(__i1, __i2, __s, traits_type::length(__s)); + } +# 1797 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, size_type __n, + _CharT __c) + { + + ; + return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c); + } +# 1822 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + template> + basic_string& + replace(const_iterator __i1, const_iterator __i2, + _InputIterator __k1, _InputIterator __k2) + { + + ; + ; + return this->_M_replace_dispatch(__i1, __i2, __k1, __k2, + std::__false_type()); + } +# 1854 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, + _CharT* __k1, _CharT* __k2) + { + + ; + ; + return this->replace(__i1 - begin(), __i2 - __i1, + __k1, __k2 - __k1); + } + + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, + const _CharT* __k1, const _CharT* __k2) + { + + ; + ; + return this->replace(__i1 - begin(), __i2 - __i1, + __k1, __k2 - __k1); + } + + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, + iterator __k1, iterator __k2) + { + + ; + ; + return this->replace(__i1 - begin(), __i2 - __i1, + __k1.base(), __k2 - __k1); + } + + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, + const_iterator __k1, const_iterator __k2) + { + + ; + ; + return this->replace(__i1 - begin(), __i2 - __i1, + __k1.base(), __k2 - __k1); + } +# 1913 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string& replace(const_iterator __i1, const_iterator __i2, + initializer_list<_CharT> __l) + { return this->replace(__i1, __i2, __l.begin(), __l.end()); } + + + private: + template + basic_string& + _M_replace_dispatch(const_iterator __i1, const_iterator __i2, + _Integer __n, _Integer __val, __true_type) + { return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __val); } + + template + basic_string& + _M_replace_dispatch(const_iterator __i1, const_iterator __i2, + _InputIterator __k1, _InputIterator __k2, + __false_type); + + basic_string& + _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2, + _CharT __c); + + basic_string& + _M_replace(size_type __pos, size_type __len1, const _CharT* __s, + const size_type __len2); + + basic_string& + _M_append(const _CharT* __s, size_type __n); + + public: +# 1956 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + copy(_CharT* __s, size_type __n, size_type __pos = 0) const; +# 1966 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + void + swap(basic_string& __s) noexcept; +# 1976 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + const _CharT* + c_str() const noexcept + { return _M_data(); } + + + + + + + + const _CharT* + data() const noexcept + { return _M_data(); } + + + + + allocator_type + get_allocator() const noexcept + { return _M_get_allocator(); } +# 2009 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + find(const _CharT* __s, size_type __pos, size_type __n) const; +# 2022 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + find(const basic_string& __str, size_type __pos = 0) const + noexcept + { return this->find(__str.data(), __pos, __str.size()); } +# 2037 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + find(const _CharT* __s, size_type __pos = 0) const + { + ; + return this->find(__s, __pos, traits_type::length(__s)); + } +# 2054 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + find(_CharT __c, size_type __pos = 0) const noexcept; +# 2067 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + rfind(const basic_string& __str, size_type __pos = npos) const + noexcept + { return this->rfind(__str.data(), __pos, __str.size()); } +# 2084 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + rfind(const _CharT* __s, size_type __pos, size_type __n) const; +# 2097 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + rfind(const _CharT* __s, size_type __pos = npos) const + { + ; + return this->rfind(__s, __pos, traits_type::length(__s)); + } +# 2114 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + rfind(_CharT __c, size_type __pos = npos) const noexcept; +# 2128 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + find_first_of(const basic_string& __str, size_type __pos = 0) const + noexcept + { return this->find_first_of(__str.data(), __pos, __str.size()); } +# 2145 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + find_first_of(const _CharT* __s, size_type __pos, size_type __n) const; +# 2158 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + find_first_of(const _CharT* __s, size_type __pos = 0) const + { + ; + return this->find_first_of(__s, __pos, traits_type::length(__s)); + } +# 2177 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + find_first_of(_CharT __c, size_type __pos = 0) const noexcept + { return this->find(__c, __pos); } +# 2192 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + find_last_of(const basic_string& __str, size_type __pos = npos) const + noexcept + { return this->find_last_of(__str.data(), __pos, __str.size()); } +# 2209 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + find_last_of(const _CharT* __s, size_type __pos, size_type __n) const; +# 2222 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + find_last_of(const _CharT* __s, size_type __pos = npos) const + { + ; + return this->find_last_of(__s, __pos, traits_type::length(__s)); + } +# 2241 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + find_last_of(_CharT __c, size_type __pos = npos) const noexcept + { return this->rfind(__c, __pos); } +# 2255 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + find_first_not_of(const basic_string& __str, size_type __pos = 0) const + noexcept + { return this->find_first_not_of(__str.data(), __pos, __str.size()); } +# 2272 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + find_first_not_of(const _CharT* __s, size_type __pos, + size_type __n) const; +# 2286 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + find_first_not_of(const _CharT* __s, size_type __pos = 0) const + { + ; + return this->find_first_not_of(__s, __pos, traits_type::length(__s)); + } +# 2303 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + find_first_not_of(_CharT __c, size_type __pos = 0) const + noexcept; +# 2318 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + find_last_not_of(const basic_string& __str, size_type __pos = npos) const + noexcept + { return this->find_last_not_of(__str.data(), __pos, __str.size()); } +# 2335 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + find_last_not_of(const _CharT* __s, size_type __pos, + size_type __n) const; +# 2349 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + find_last_not_of(const _CharT* __s, size_type __pos = npos) const + { + ; + return this->find_last_not_of(__s, __pos, traits_type::length(__s)); + } +# 2366 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + size_type + find_last_not_of(_CharT __c, size_type __pos = npos) const + noexcept; +# 2382 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + basic_string + substr(size_type __pos = 0, size_type __n = npos) const + { return basic_string(*this, + _M_check(__pos, "basic_string::substr"), __n); } +# 2401 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + int + compare(const basic_string& __str) const + { + const size_type __size = this->size(); + const size_type __osize = __str.size(); + const size_type __len = std::min(__size, __osize); + + int __r = traits_type::compare(_M_data(), __str.data(), __len); + if (!__r) + __r = _S_compare(__size, __osize); + return __r; + } +# 2433 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + int + compare(size_type __pos, size_type __n, const basic_string& __str) const; +# 2459 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + int + compare(size_type __pos1, size_type __n1, const basic_string& __str, + size_type __pos2, size_type __n2) const; +# 2477 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + int + compare(const _CharT* __s) const; +# 2501 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + int + compare(size_type __pos, size_type __n1, const _CharT* __s) const; +# 2528 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + int + compare(size_type __pos, size_type __n1, const _CharT* __s, + size_type __n2) const; + }; +} +# 4927 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + template + basic_string<_CharT, _Traits, _Alloc> + operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { + basic_string<_CharT, _Traits, _Alloc> __str(__lhs); + __str.append(__rhs); + return __str; + } + + + + + + + + template + basic_string<_CharT,_Traits,_Alloc> + operator+(const _CharT* __lhs, + const basic_string<_CharT,_Traits,_Alloc>& __rhs); + + + + + + + + template + basic_string<_CharT,_Traits,_Alloc> + operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs); + + + + + + + + template + inline basic_string<_CharT, _Traits, _Alloc> + operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { + basic_string<_CharT, _Traits, _Alloc> __str(__lhs); + __str.append(__rhs); + return __str; + } + + + + + + + + template + inline basic_string<_CharT, _Traits, _Alloc> + operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs) + { + typedef basic_string<_CharT, _Traits, _Alloc> __string_type; + typedef typename __string_type::size_type __size_type; + __string_type __str(__lhs); + __str.append(__size_type(1), __rhs); + return __str; + } + + + template + inline basic_string<_CharT, _Traits, _Alloc> + operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return std::move(__lhs.append(__rhs)); } + + template + inline basic_string<_CharT, _Traits, _Alloc> + operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + basic_string<_CharT, _Traits, _Alloc>&& __rhs) + { return std::move(__rhs.insert(0, __lhs)); } + + template + inline basic_string<_CharT, _Traits, _Alloc> + operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, + basic_string<_CharT, _Traits, _Alloc>&& __rhs) + { + const auto __size = __lhs.size() + __rhs.size(); + const bool __cond = (__size > __lhs.capacity() + && __size <= __rhs.capacity()); + return __cond ? std::move(__rhs.insert(0, __lhs)) + : std::move(__lhs.append(__rhs)); + } + + template + inline basic_string<_CharT, _Traits, _Alloc> + operator+(const _CharT* __lhs, + basic_string<_CharT, _Traits, _Alloc>&& __rhs) + { return std::move(__rhs.insert(0, __lhs)); } + + template + inline basic_string<_CharT, _Traits, _Alloc> + operator+(_CharT __lhs, + basic_string<_CharT, _Traits, _Alloc>&& __rhs) + { return std::move(__rhs.insert(0, 1, __lhs)); } + + template + inline basic_string<_CharT, _Traits, _Alloc> + operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, + const _CharT* __rhs) + { return std::move(__lhs.append(__rhs)); } + + template + inline basic_string<_CharT, _Traits, _Alloc> + operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, + _CharT __rhs) + { return std::move(__lhs.append(1, __rhs)); } +# 5048 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + template + inline bool + operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + noexcept + { return __lhs.compare(__rhs) == 0; } + + template + inline + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type + operator==(const basic_string<_CharT>& __lhs, + const basic_string<_CharT>& __rhs) noexcept + { return (__lhs.size() == __rhs.size() + && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(), + __lhs.size())); } + + + + + + + + template + inline bool + operator==(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) == 0; } + + + + + + + + template + inline bool + operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) == 0; } +# 5095 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + template + inline bool + operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + noexcept + { return !(__lhs == __rhs); } + + + + + + + + template + inline bool + operator!=(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return !(__lhs == __rhs); } + + + + + + + + template + inline bool + operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return !(__lhs == __rhs); } +# 5133 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + template + inline bool + operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + noexcept + { return __lhs.compare(__rhs) < 0; } + + + + + + + + template + inline bool + operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) < 0; } + + + + + + + + template + inline bool + operator<(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) > 0; } +# 5171 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + template + inline bool + operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + noexcept + { return __lhs.compare(__rhs) > 0; } + + + + + + + + template + inline bool + operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) > 0; } + + + + + + + + template + inline bool + operator>(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) < 0; } +# 5209 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + template + inline bool + operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + noexcept + { return __lhs.compare(__rhs) <= 0; } + + + + + + + + template + inline bool + operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) <= 0; } + + + + + + + + template + inline bool + operator<=(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) >= 0; } +# 5247 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + template + inline bool + operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + noexcept + { return __lhs.compare(__rhs) >= 0; } + + + + + + + + template + inline bool + operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) >= 0; } + + + + + + + + template + inline bool + operator>=(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) <= 0; } +# 5285 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + template + inline void + swap(basic_string<_CharT, _Traits, _Alloc>& __lhs, + basic_string<_CharT, _Traits, _Alloc>& __rhs) + noexcept(noexcept(__lhs.swap(__rhs))) + { __lhs.swap(__rhs); } +# 5305 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + template + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, + basic_string<_CharT, _Traits, _Alloc>& __str); + + template<> + basic_istream& + operator>>(basic_istream& __is, basic_string& __str); +# 5323 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, + const basic_string<_CharT, _Traits, _Alloc>& __str) + { + + + return __ostream_insert(__os, __str.data(), __str.size()); + } +# 5346 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + template + basic_istream<_CharT, _Traits>& + getline(basic_istream<_CharT, _Traits>& __is, + basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim); +# 5363 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + template + inline basic_istream<_CharT, _Traits>& + getline(basic_istream<_CharT, _Traits>& __is, + basic_string<_CharT, _Traits, _Alloc>& __str) + { return std::getline(__is, __str, __is.widen('\n')); } + + + + template + inline basic_istream<_CharT, _Traits>& + getline(basic_istream<_CharT, _Traits>&& __is, + basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim) + { return std::getline(__is, __str, __delim); } + + + template + inline basic_istream<_CharT, _Traits>& + getline(basic_istream<_CharT, _Traits>&& __is, + basic_string<_CharT, _Traits, _Alloc>& __str) + { return std::getline(__is, __str); } + + + template<> + basic_istream& + getline(basic_istream& __in, basic_string& __str, + char __delim); + + + template<> + basic_istream& + getline(basic_istream& __in, basic_string& __str, + wchar_t __delim); + + + +} + + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/string_conversions.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/string_conversions.h" 3 + + + + + + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3 +# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/string_conversions.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3 + + + + +# 1 "/usr/include/wchar.h" 1 3 4 +# 45 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 2 3 +# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/string_conversions.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdio" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdio" 3 +# 96 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdio" 3 +namespace std +{ + using ::FILE; + using ::fpos_t; + + using ::clearerr; + using ::fclose; + using ::feof; + using ::ferror; + using ::fflush; + using ::fgetc; + using ::fgetpos; + using ::fgets; + using ::fopen; + using ::fprintf; + using ::fputc; + using ::fputs; + using ::fread; + using ::freopen; + using ::fscanf; + using ::fseek; + using ::fsetpos; + using ::ftell; + using ::fwrite; + using ::getc; + using ::getchar; + + + + + using ::perror; + using ::printf; + using ::putc; + using ::putchar; + using ::puts; + using ::remove; + using ::rename; + using ::rewind; + using ::scanf; + using ::setbuf; + using ::setvbuf; + using ::sprintf; + using ::sscanf; + using ::tmpfile; + + using ::tmpnam; + + using ::ungetc; + using ::vfprintf; + using ::vprintf; + using ::vsprintf; +} +# 157 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdio" 3 +namespace __gnu_cxx +{ +# 175 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdio" 3 + using ::snprintf; + using ::vfscanf; + using ::vscanf; + using ::vsnprintf; + using ::vsscanf; + +} + +namespace std +{ + using ::__gnu_cxx::snprintf; + using ::__gnu_cxx::vfscanf; + using ::__gnu_cxx::vscanf; + using ::__gnu_cxx::vsnprintf; + using ::__gnu_cxx::vsscanf; +} +# 44 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/string_conversions.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cerrno" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cerrno" 3 + + +# 1 "/usr/include/errno.h" 1 3 4 +# 31 "/usr/include/errno.h" 3 4 +extern "C" { + + + + +# 1 "/usr/include/bits/errno.h" 1 3 4 +# 24 "/usr/include/bits/errno.h" 3 4 +# 1 "/usr/include/linux/errno.h" 1 3 4 +# 1 "/usr/include/asm/errno.h" 1 3 4 +# 1 "/usr/include/asm-generic/errno.h" 1 3 4 + + + +# 1 "/usr/include/asm-generic/errno-base.h" 1 3 4 +# 5 "/usr/include/asm-generic/errno.h" 2 3 4 +# 2 "/usr/include/asm/errno.h" 2 3 4 +# 2 "/usr/include/linux/errno.h" 2 3 4 +# 25 "/usr/include/bits/errno.h" 2 3 4 +# 50 "/usr/include/bits/errno.h" 3 4 +extern int *__errno_location (void) throw () __attribute__ ((__const__)); +# 36 "/usr/include/errno.h" 2 3 4 +# 54 "/usr/include/errno.h" 3 4 +extern char *program_invocation_name, *program_invocation_short_name; + + + +} +# 68 "/usr/include/errno.h" 3 4 +typedef int error_t; +# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cerrno" 2 3 +# 45 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/string_conversions.h" 2 3 + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + template + _Ret + __stoa(_TRet (*__convf) (const _CharT*, _CharT**, _Base...), + const char* __name, const _CharT* __str, std::size_t* __idx, + _Base... __base) + { + _Ret __ret; + + _CharT* __endptr; + + struct _Save_errno { + _Save_errno() : _M_errno((*__errno_location ())) { (*__errno_location ()) = 0; } + ~_Save_errno() { if ((*__errno_location ()) == 0) (*__errno_location ()) = _M_errno; } + int _M_errno; + } const __save_errno; + + const _TRet __tmp = __convf(__str, &__endptr, __base...); + + if (__endptr == __str) + std::__throw_invalid_argument(__name); + else if ((*__errno_location ()) == 34 + || (std::__are_same<_Ret, int>::__value + && (__tmp < __numeric_traits::__min + || __tmp > __numeric_traits::__max))) + std::__throw_out_of_range(__name); + else + __ret = __tmp; + + if (__idx) + *__idx = __endptr - __str; + + return __ret; + } + + + template + _String + __to_xstring(int (*__convf) (_CharT*, std::size_t, const _CharT*, + __builtin_va_list), std::size_t __n, + const _CharT* __fmt, ...) + { + + + _CharT* __s = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __n)); + + __builtin_va_list __args; + __builtin_va_start(__args, __fmt); + + const int __len = __convf(__s, __n, __fmt, __args); + + __builtin_va_end(__args); + + return _String(__s, __s + __len); + } + + +} +# 5403 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +namespace __cxx11 { + + + + inline int + stoi(const string& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::strtol, "stoi", __str.c_str(), + __idx, __base); } + + inline long + stol(const string& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(), + __idx, __base); } + + inline unsigned long + stoul(const string& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(), + __idx, __base); } + + inline long long + stoll(const string& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(), + __idx, __base); } + + inline unsigned long long + stoull(const string& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(), + __idx, __base); } + + + inline float + stof(const string& __str, size_t* __idx = 0) + { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); } + + inline double + stod(const string& __str, size_t* __idx = 0) + { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); } + + inline long double + stold(const string& __str, size_t* __idx = 0) + { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); } + + + + + + + inline string + to_string(int __val) + { return __gnu_cxx::__to_xstring(&std::vsnprintf, 4 * sizeof(int), + "%d", __val); } + + inline string + to_string(unsigned __val) + { return __gnu_cxx::__to_xstring(&std::vsnprintf, + 4 * sizeof(unsigned), + "%u", __val); } + + inline string + to_string(long __val) + { return __gnu_cxx::__to_xstring(&std::vsnprintf, 4 * sizeof(long), + "%ld", __val); } + + inline string + to_string(unsigned long __val) + { return __gnu_cxx::__to_xstring(&std::vsnprintf, + 4 * sizeof(unsigned long), + "%lu", __val); } + + inline string + to_string(long long __val) + { return __gnu_cxx::__to_xstring(&std::vsnprintf, + 4 * sizeof(long long), + "%lld", __val); } + + inline string + to_string(unsigned long long __val) + { return __gnu_cxx::__to_xstring(&std::vsnprintf, + 4 * sizeof(unsigned long long), + "%llu", __val); } + + inline string + to_string(float __val) + { + const int __n = + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vsnprintf, __n, + "%f", __val); + } + + inline string + to_string(double __val) + { + const int __n = + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vsnprintf, __n, + "%f", __val); + } + + inline string + to_string(long double __val) + { + const int __n = + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vsnprintf, __n, + "%Lf", __val); + } + + + + inline int + stoi(const wstring& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::wcstol, "stoi", __str.c_str(), + __idx, __base); } + + inline long + stol(const wstring& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(), + __idx, __base); } + + inline unsigned long + stoul(const wstring& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(), + __idx, __base); } + + inline long long + stoll(const wstring& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(), + __idx, __base); } + + inline unsigned long long + stoull(const wstring& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(), + __idx, __base); } + + + inline float + stof(const wstring& __str, size_t* __idx = 0) + { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); } + + inline double + stod(const wstring& __str, size_t* __idx = 0) + { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); } + + inline long double + stold(const wstring& __str, size_t* __idx = 0) + { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); } + + + + inline wstring + to_wstring(int __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, 4 * sizeof(int), + L"%d", __val); } + + inline wstring + to_wstring(unsigned __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, + 4 * sizeof(unsigned), + L"%u", __val); } + + inline wstring + to_wstring(long __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, 4 * sizeof(long), + L"%ld", __val); } + + inline wstring + to_wstring(unsigned long __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, + 4 * sizeof(unsigned long), + L"%lu", __val); } + + inline wstring + to_wstring(long long __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, + 4 * sizeof(long long), + L"%lld", __val); } + + inline wstring + to_wstring(unsigned long long __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, + 4 * sizeof(unsigned long long), + L"%llu", __val); } + + inline wstring + to_wstring(float __val) + { + const int __n = + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vswprintf, __n, + L"%f", __val); + } + + inline wstring + to_wstring(double __val) + { + const int __n = + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vswprintf, __n, + L"%f", __val); + } + + inline wstring + to_wstring(long double __val) + { + const int __n = + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vswprintf, __n, + L"%Lf", __val); + } + + + +} + +} + + + + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functional_hash.h" 1 3 +# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functional_hash.h" 3 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/hash_bytes.h" 1 3 +# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/hash_bytes.h" 3 + + + +namespace std +{ + + + + + + + + size_t + _Hash_bytes(const void* __ptr, size_t __len, size_t __seed); + + + + + + size_t + _Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed); + + +} +# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functional_hash.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 49 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functional_hash.h" 3 + template + struct __hash_base + { + typedef _Result result_type; + typedef _Arg argument_type; + }; + + + template + struct hash; + + + template::value> + struct __hash_enum + { + private: + + __hash_enum(__hash_enum&&); + ~__hash_enum(); + }; + + + template + struct __hash_enum<_Tp, true> : public __hash_base + { + size_t + operator()(_Tp __val) const noexcept + { + using __type = typename underlying_type<_Tp>::type; + return hash<__type>{}(static_cast<__type>(__val)); + } + }; + + + + template + struct hash : __hash_enum<_Tp> + { }; + + + template + struct hash<_Tp*> : public __hash_base + { + size_t + operator()(_Tp* __p) const noexcept + { return reinterpret_cast(__p); } + }; +# 108 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functional_hash.h" 3 + template<> struct hash : public __hash_base { size_t operator()(bool __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(char __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(signed char __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned char __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(wchar_t __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(char16_t __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(char32_t __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(short __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(int __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(long __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(long long __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned short __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned int __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned long __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned long long __val) const noexcept { return static_cast(__val); } }; +# 171 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functional_hash.h" 3 + struct _Hash_impl + { + static size_t + hash(const void* __ptr, size_t __clength, + size_t __seed = static_cast(0xc70f6907UL)) + { return _Hash_bytes(__ptr, __clength, __seed); } + + template + static size_t + hash(const _Tp& __val) + { return hash(&__val, sizeof(__val)); } + + template + static size_t + __hash_combine(const _Tp& __val, size_t __hash) + { return hash(&__val, sizeof(__val), __hash); } + }; + + struct _Fnv_hash_impl + { + static size_t + hash(const void* __ptr, size_t __clength, + size_t __seed = static_cast(2166136261UL)) + { return _Fnv_hash_bytes(__ptr, __clength, __seed); } + + template + static size_t + hash(const _Tp& __val) + { return hash(&__val, sizeof(__val)); } + + template + static size_t + __hash_combine(const _Tp& __val, size_t __hash) + { return hash(&__val, sizeof(__val), __hash); } + }; + + + template<> + struct hash : public __hash_base + { + size_t + operator()(float __val) const noexcept + { + + return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0; + } + }; + + + template<> + struct hash : public __hash_base + { + size_t + operator()(double __val) const noexcept + { + + return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0; + } + }; + + + template<> + struct hash + : public __hash_base + { + __attribute__ ((__pure__)) size_t + operator()(long double __val) const noexcept; + }; + + + + + + + + template + struct __is_fast_hash : public std::true_type + { }; + + template<> + struct __is_fast_hash> : public std::false_type + { }; + + +} +# 5629 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + template<> + struct hash + : public __hash_base + { + size_t + operator()(const string& __s) const noexcept + { return std::_Hash_impl::hash(__s.data(), __s.length()); } + }; + + template<> + struct __is_fast_hash> : std::false_type + { }; + + + + template<> + struct hash + : public __hash_base + { + size_t + operator()(const wstring& __s) const noexcept + { return std::_Hash_impl::hash(__s.data(), + __s.length() * sizeof(wchar_t)); } + }; + + template<> + struct __is_fast_hash> : std::false_type + { }; + + + + + + template<> + struct hash + : public __hash_base + { + size_t + operator()(const u16string& __s) const noexcept + { return std::_Hash_impl::hash(__s.data(), + __s.length() * sizeof(char16_t)); } + }; + + template<> + struct __is_fast_hash> : std::false_type + { }; + + + template<> + struct hash + : public __hash_base + { + size_t + operator()(const u32string& __s) const noexcept + { return std::_Hash_impl::hash(__s.data(), + __s.length() * sizeof(char32_t)); } + }; + + template<> + struct __is_fast_hash> : std::false_type + { }; +# 5707 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3 + inline namespace literals + { + inline namespace string_literals + { + + + __attribute ((__abi_tag__ ("cxx11"))) + inline basic_string + operator""s(const char* __str, size_t __len) + { return basic_string{__str, __len}; } + + + __attribute ((__abi_tag__ ("cxx11"))) + inline basic_string + operator""s(const wchar_t* __str, size_t __len) + { return basic_string{__str, __len}; } + + + + __attribute ((__abi_tag__ ("cxx11"))) + inline basic_string + operator""s(const char16_t* __str, size_t __len) + { return basic_string{__str, __len}; } + + __attribute ((__abi_tag__ ("cxx11"))) + inline basic_string + operator""s(const char32_t* __str, size_t __len) + { return basic_string{__str, __len}; } + + + + } + } + + + +} +# 53 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.tcc" 1 3 +# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.tcc" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template + const typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>::npos; + + template + void + basic_string<_CharT, _Traits, _Alloc>:: + swap(basic_string& __s) noexcept + { + if (this == &__s) + return; + + _Alloc_traits::_S_on_swap(_M_get_allocator(), __s._M_get_allocator()); + + if (_M_is_local()) + if (__s._M_is_local()) + { + if (length() && __s.length()) + { + _CharT __tmp_data[_S_local_capacity + 1]; + traits_type::copy(__tmp_data, __s._M_local_buf, + _S_local_capacity + 1); + traits_type::copy(__s._M_local_buf, _M_local_buf, + _S_local_capacity + 1); + traits_type::copy(_M_local_buf, __tmp_data, + _S_local_capacity + 1); + } + else if (__s.length()) + { + traits_type::copy(_M_local_buf, __s._M_local_buf, + _S_local_capacity + 1); + _M_length(__s.length()); + __s._M_set_length(0); + return; + } + else if (length()) + { + traits_type::copy(__s._M_local_buf, _M_local_buf, + _S_local_capacity + 1); + __s._M_length(length()); + _M_set_length(0); + return; + } + } + else + { + const size_type __tmp_capacity = __s._M_allocated_capacity; + traits_type::copy(__s._M_local_buf, _M_local_buf, + _S_local_capacity + 1); + _M_data(__s._M_data()); + __s._M_data(__s._M_local_buf); + _M_capacity(__tmp_capacity); + } + else + { + const size_type __tmp_capacity = _M_allocated_capacity; + if (__s._M_is_local()) + { + traits_type::copy(_M_local_buf, __s._M_local_buf, + _S_local_capacity + 1); + __s._M_data(_M_data()); + _M_data(_M_local_buf); + } + else + { + pointer __tmp_ptr = _M_data(); + _M_data(__s._M_data()); + __s._M_data(__tmp_ptr); + _M_capacity(__s._M_allocated_capacity); + } + __s._M_capacity(__tmp_capacity); + } + + const size_type __tmp_length = length(); + _M_length(__s.length()); + __s._M_length(__tmp_length); + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::pointer + basic_string<_CharT, _Traits, _Alloc>:: + _M_create(size_type& __capacity, size_type __old_capacity) + { + + + if (__capacity > max_size()) + std::__throw_length_error(("basic_string::_M_create")); + + + + + if (__capacity > __old_capacity && __capacity < 2 * __old_capacity) + { + __capacity = 2 * __old_capacity; + + if (__capacity > max_size()) + __capacity = max_size(); + } + + + + return _Alloc_traits::allocate(_M_get_allocator(), __capacity + 1); + } + + + + + + template + template + void + basic_string<_CharT, _Traits, _Alloc>:: + _M_construct(_InIterator __beg, _InIterator __end, + std::input_iterator_tag) + { + size_type __len = 0; + size_type __capacity = size_type(_S_local_capacity); + + while (__beg != __end && __len < __capacity) + { + _M_data()[__len++] = *__beg; + ++__beg; + } + + try + { + while (__beg != __end) + { + if (__len == __capacity) + { + + __capacity = __len + 1; + pointer __another = _M_create(__capacity, __len); + this->_S_copy(__another, _M_data(), __len); + _M_dispose(); + _M_data(__another); + _M_capacity(__capacity); + } + _M_data()[__len++] = *__beg; + ++__beg; + } + } + catch(...) + { + _M_dispose(); + throw; + } + + _M_set_length(__len); + } + + template + template + void + basic_string<_CharT, _Traits, _Alloc>:: + _M_construct(_InIterator __beg, _InIterator __end, + std::forward_iterator_tag) + { + + if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end) + std::__throw_logic_error(("basic_string::" "_M_construct null not valid")); + + + size_type __dnew = static_cast(std::distance(__beg, __end)); + + if (__dnew > size_type(_S_local_capacity)) + { + _M_data(_M_create(__dnew, size_type(0))); + _M_capacity(__dnew); + } + + + try + { this->_S_copy_chars(_M_data(), __beg, __end); } + catch(...) + { + _M_dispose(); + throw; + } + + _M_set_length(__dnew); + } + + template + void + basic_string<_CharT, _Traits, _Alloc>:: + _M_construct(size_type __n, _CharT __c) + { + if (__n > size_type(_S_local_capacity)) + { + _M_data(_M_create(__n, size_type(0))); + _M_capacity(__n); + } + + if (__n) + this->_S_assign(_M_data(), __n, __c); + + _M_set_length(__n); + } + + template + void + basic_string<_CharT, _Traits, _Alloc>:: + _M_assign(const basic_string& __str) + { + if (this != &__str) + { + const size_type __rsize = __str.length(); + const size_type __capacity = capacity(); + + if (__rsize > __capacity) + { + size_type __new_capacity = __rsize; + pointer __tmp = _M_create(__new_capacity, __capacity); + _M_dispose(); + _M_data(__tmp); + _M_capacity(__new_capacity); + } + + if (__rsize) + this->_S_copy(_M_data(), __str._M_data(), __rsize); + + _M_set_length(__rsize); + } + } + + template + void + basic_string<_CharT, _Traits, _Alloc>:: + reserve(size_type __res) + { + + if (__res < length()) + __res = length(); + + const size_type __capacity = capacity(); + if (__res != __capacity) + { + if (__res > __capacity + || __res > size_type(_S_local_capacity)) + { + pointer __tmp = _M_create(__res, __capacity); + this->_S_copy(__tmp, _M_data(), length() + 1); + _M_dispose(); + _M_data(__tmp); + _M_capacity(__res); + } + else if (!_M_is_local()) + { + this->_S_copy(_M_local_data(), _M_data(), length() + 1); + _M_destroy(__capacity); + _M_data(_M_local_data()); + } + } + } + + template + void + basic_string<_CharT, _Traits, _Alloc>:: + _M_mutate(size_type __pos, size_type __len1, const _CharT* __s, + size_type __len2) + { + const size_type __how_much = length() - __pos - __len1; + + size_type __new_capacity = length() + __len2 - __len1; + pointer __r = _M_create(__new_capacity, capacity()); + + if (__pos) + this->_S_copy(__r, _M_data(), __pos); + if (__s && __len2) + this->_S_copy(__r + __pos, __s, __len2); + if (__how_much) + this->_S_copy(__r + __pos + __len2, + _M_data() + __pos + __len1, __how_much); + + _M_dispose(); + _M_data(__r); + _M_capacity(__new_capacity); + } + + template + void + basic_string<_CharT, _Traits, _Alloc>:: + _M_erase(size_type __pos, size_type __n) + { + const size_type __how_much = length() - __pos - __n; + + if (__how_much && __n) + this->_S_move(_M_data() + __pos, _M_data() + __pos + __n, __how_much); + + _M_set_length(length() - __n); + } + + template + void + basic_string<_CharT, _Traits, _Alloc>:: + resize(size_type __n, _CharT __c) + { + const size_type __size = this->size(); + if (__size < __n) + this->append(__n - __size, __c); + else if (__n < __size) + this->_M_erase(__n, __size - __n); + } + + template + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + _M_append(const _CharT* __s, size_type __n) + { + const size_type __len = __n + this->size(); + + if (__len <= this->capacity()) + { + if (__n) + this->_S_copy(this->_M_data() + this->size(), __s, __n); + } + else + this->_M_mutate(this->size(), size_type(0), __s, __n); + + this->_M_set_length(__len); + return *this; + } + + template + template + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + _M_replace_dispatch(const_iterator __i1, const_iterator __i2, + _InputIterator __k1, _InputIterator __k2, + std::__false_type) + { + const basic_string __s(__k1, __k2); + const size_type __n1 = __i2 - __i1; + return _M_replace(__i1 - begin(), __n1, __s._M_data(), + __s.size()); + } + + template + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2, + _CharT __c) + { + _M_check_length(__n1, __n2, "basic_string::_M_replace_aux"); + + const size_type __old_size = this->size(); + const size_type __new_size = __old_size + __n2 - __n1; + + if (__new_size <= this->capacity()) + { + pointer __p = this->_M_data() + __pos1; + + const size_type __how_much = __old_size - __pos1 - __n1; + if (__how_much && __n1 != __n2) + this->_S_move(__p + __n2, __p + __n1, __how_much); + } + else + this->_M_mutate(__pos1, __n1, 0, __n2); + + if (__n2) + this->_S_assign(this->_M_data() + __pos1, __n2, __c); + + this->_M_set_length(__new_size); + return *this; + } + + template + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + _M_replace(size_type __pos, size_type __len1, const _CharT* __s, + const size_type __len2) + { + _M_check_length(__len1, __len2, "basic_string::_M_replace"); + + const size_type __old_size = this->size(); + const size_type __new_size = __old_size + __len2 - __len1; + + if (__new_size <= this->capacity()) + { + pointer __p = this->_M_data() + __pos; + + const size_type __how_much = __old_size - __pos - __len1; + if (_M_disjunct(__s)) + { + if (__how_much && __len1 != __len2) + this->_S_move(__p + __len2, __p + __len1, __how_much); + if (__len2) + this->_S_copy(__p, __s, __len2); + } + else + { + + if (__len2 && __len2 <= __len1) + this->_S_move(__p, __s, __len2); + if (__how_much && __len1 != __len2) + this->_S_move(__p + __len2, __p + __len1, __how_much); + if (__len2 > __len1) + { + if (__s + __len2 <= __p + __len1) + this->_S_move(__p, __s, __len2); + else if (__s >= __p + __len1) + this->_S_copy(__p, __s + __len2 - __len1, __len2); + else + { + const size_type __nleft = (__p + __len1) - __s; + this->_S_move(__p, __s, __nleft); + this->_S_copy(__p + __nleft, __p + __len2, + __len2 - __nleft); + } + } + } + } + else + this->_M_mutate(__pos, __len1, __s, __len2); + + this->_M_set_length(__new_size); + return *this; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + copy(_CharT* __s, size_type __n, size_type __pos) const + { + _M_check(__pos, "basic_string::copy"); + __n = _M_limit(__pos, __n); + ; + if (__n) + _S_copy(__s, _M_data() + __pos, __n); + + return __n; + } +# 1145 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.tcc" 3 + template + basic_string<_CharT, _Traits, _Alloc> + operator+(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { + ; + typedef basic_string<_CharT, _Traits, _Alloc> __string_type; + typedef typename __string_type::size_type __size_type; + const __size_type __len = _Traits::length(__lhs); + __string_type __str; + __str.reserve(__len + __rhs.size()); + __str.append(__lhs, __len); + __str.append(__rhs); + return __str; + } + + template + basic_string<_CharT, _Traits, _Alloc> + operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { + typedef basic_string<_CharT, _Traits, _Alloc> __string_type; + typedef typename __string_type::size_type __size_type; + __string_type __str; + const __size_type __len = __rhs.size(); + __str.reserve(__len + 1); + __str.append(__size_type(1), __lhs); + __str.append(__rhs); + return __str; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find(const _CharT* __s, size_type __pos, size_type __n) const + { + ; + const size_type __size = this->size(); + const _CharT* __data = _M_data(); + + if (__n == 0) + return __pos <= __size ? __pos : npos; + + if (__n <= __size) + { + for (; __pos <= __size - __n; ++__pos) + if (traits_type::eq(__data[__pos], __s[0]) + && traits_type::compare(__data + __pos + 1, + __s + 1, __n - 1) == 0) + return __pos; + } + return npos; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find(_CharT __c, size_type __pos) const noexcept + { + size_type __ret = npos; + const size_type __size = this->size(); + if (__pos < __size) + { + const _CharT* __data = _M_data(); + const size_type __n = __size - __pos; + const _CharT* __p = traits_type::find(__data + __pos, __n, __c); + if (__p) + __ret = __p - __data; + } + return __ret; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + rfind(const _CharT* __s, size_type __pos, size_type __n) const + { + ; + const size_type __size = this->size(); + if (__n <= __size) + { + __pos = std::min(size_type(__size - __n), __pos); + const _CharT* __data = _M_data(); + do + { + if (traits_type::compare(__data + __pos, __s, __n) == 0) + return __pos; + } + while (__pos-- > 0); + } + return npos; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + rfind(_CharT __c, size_type __pos) const noexcept + { + size_type __size = this->size(); + if (__size) + { + if (--__size > __pos) + __size = __pos; + for (++__size; __size-- > 0; ) + if (traits_type::eq(_M_data()[__size], __c)) + return __size; + } + return npos; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find_first_of(const _CharT* __s, size_type __pos, size_type __n) const + { + ; + for (; __n && __pos < this->size(); ++__pos) + { + const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]); + if (__p) + return __pos; + } + return npos; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find_last_of(const _CharT* __s, size_type __pos, size_type __n) const + { + ; + size_type __size = this->size(); + if (__size && __n) + { + if (--__size > __pos) + __size = __pos; + do + { + if (traits_type::find(__s, __n, _M_data()[__size])) + return __size; + } + while (__size-- != 0); + } + return npos; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const + { + ; + for (; __pos < this->size(); ++__pos) + if (!traits_type::find(__s, __n, _M_data()[__pos])) + return __pos; + return npos; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find_first_not_of(_CharT __c, size_type __pos) const noexcept + { + for (; __pos < this->size(); ++__pos) + if (!traits_type::eq(_M_data()[__pos], __c)) + return __pos; + return npos; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const + { + ; + size_type __size = this->size(); + if (__size) + { + if (--__size > __pos) + __size = __pos; + do + { + if (!traits_type::find(__s, __n, _M_data()[__size])) + return __size; + } + while (__size--); + } + return npos; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find_last_not_of(_CharT __c, size_type __pos) const noexcept + { + size_type __size = this->size(); + if (__size) + { + if (--__size > __pos) + __size = __pos; + do + { + if (!traits_type::eq(_M_data()[__size], __c)) + return __size; + } + while (__size--); + } + return npos; + } + + template + int + basic_string<_CharT, _Traits, _Alloc>:: + compare(size_type __pos, size_type __n, const basic_string& __str) const + { + _M_check(__pos, "basic_string::compare"); + __n = _M_limit(__pos, __n); + const size_type __osize = __str.size(); + const size_type __len = std::min(__n, __osize); + int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len); + if (!__r) + __r = _S_compare(__n, __osize); + return __r; + } + + template + int + basic_string<_CharT, _Traits, _Alloc>:: + compare(size_type __pos1, size_type __n1, const basic_string& __str, + size_type __pos2, size_type __n2) const + { + _M_check(__pos1, "basic_string::compare"); + __str._M_check(__pos2, "basic_string::compare"); + __n1 = _M_limit(__pos1, __n1); + __n2 = __str._M_limit(__pos2, __n2); + const size_type __len = std::min(__n1, __n2); + int __r = traits_type::compare(_M_data() + __pos1, + __str.data() + __pos2, __len); + if (!__r) + __r = _S_compare(__n1, __n2); + return __r; + } + + template + int + basic_string<_CharT, _Traits, _Alloc>:: + compare(const _CharT* __s) const + { + ; + const size_type __size = this->size(); + const size_type __osize = traits_type::length(__s); + const size_type __len = std::min(__size, __osize); + int __r = traits_type::compare(_M_data(), __s, __len); + if (!__r) + __r = _S_compare(__size, __osize); + return __r; + } + + template + int + basic_string <_CharT, _Traits, _Alloc>:: + compare(size_type __pos, size_type __n1, const _CharT* __s) const + { + ; + _M_check(__pos, "basic_string::compare"); + __n1 = _M_limit(__pos, __n1); + const size_type __osize = traits_type::length(__s); + const size_type __len = std::min(__n1, __osize); + int __r = traits_type::compare(_M_data() + __pos, __s, __len); + if (!__r) + __r = _S_compare(__n1, __osize); + return __r; + } + + template + int + basic_string <_CharT, _Traits, _Alloc>:: + compare(size_type __pos, size_type __n1, const _CharT* __s, + size_type __n2) const + { + ; + _M_check(__pos, "basic_string::compare"); + __n1 = _M_limit(__pos, __n1); + const size_type __len = std::min(__n1, __n2); + int __r = traits_type::compare(_M_data() + __pos, __s, __len); + if (!__r) + __r = _S_compare(__n1, __n2); + return __r; + } + + + template + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __in, + basic_string<_CharT, _Traits, _Alloc>& __str) + { + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef basic_string<_CharT, _Traits, _Alloc> __string_type; + typedef typename __istream_type::ios_base __ios_base; + typedef typename __istream_type::int_type __int_type; + typedef typename __string_type::size_type __size_type; + typedef ctype<_CharT> __ctype_type; + typedef typename __ctype_type::ctype_base __ctype_base; + + __size_type __extracted = 0; + typename __ios_base::iostate __err = __ios_base::goodbit; + typename __istream_type::sentry __cerb(__in, false); + if (__cerb) + { + try + { + + __str.erase(); + _CharT __buf[128]; + __size_type __len = 0; + const streamsize __w = __in.width(); + const __size_type __n = __w > 0 ? static_cast<__size_type>(__w) + : __str.max_size(); + const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); + const __int_type __eof = _Traits::eof(); + __int_type __c = __in.rdbuf()->sgetc(); + + while (__extracted < __n + && !_Traits::eq_int_type(__c, __eof) + && !__ct.is(__ctype_base::space, + _Traits::to_char_type(__c))) + { + if (__len == sizeof(__buf) / sizeof(_CharT)) + { + __str.append(__buf, sizeof(__buf) / sizeof(_CharT)); + __len = 0; + } + __buf[__len++] = _Traits::to_char_type(__c); + ++__extracted; + __c = __in.rdbuf()->snextc(); + } + __str.append(__buf, __len); + + if (_Traits::eq_int_type(__c, __eof)) + __err |= __ios_base::eofbit; + __in.width(0); + } + catch(__cxxabiv1::__forced_unwind&) + { + __in._M_setstate(__ios_base::badbit); + throw; + } + catch(...) + { + + + + __in._M_setstate(__ios_base::badbit); + } + } + + if (!__extracted) + __err |= __ios_base::failbit; + if (__err) + __in.setstate(__err); + return __in; + } + + template + basic_istream<_CharT, _Traits>& + getline(basic_istream<_CharT, _Traits>& __in, + basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim) + { + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef basic_string<_CharT, _Traits, _Alloc> __string_type; + typedef typename __istream_type::ios_base __ios_base; + typedef typename __istream_type::int_type __int_type; + typedef typename __string_type::size_type __size_type; + + __size_type __extracted = 0; + const __size_type __n = __str.max_size(); + typename __ios_base::iostate __err = __ios_base::goodbit; + typename __istream_type::sentry __cerb(__in, true); + if (__cerb) + { + try + { + __str.erase(); + const __int_type __idelim = _Traits::to_int_type(__delim); + const __int_type __eof = _Traits::eof(); + __int_type __c = __in.rdbuf()->sgetc(); + + while (__extracted < __n + && !_Traits::eq_int_type(__c, __eof) + && !_Traits::eq_int_type(__c, __idelim)) + { + __str += _Traits::to_char_type(__c); + ++__extracted; + __c = __in.rdbuf()->snextc(); + } + + if (_Traits::eq_int_type(__c, __eof)) + __err |= __ios_base::eofbit; + else if (_Traits::eq_int_type(__c, __idelim)) + { + ++__extracted; + __in.rdbuf()->sbumpc(); + } + else + __err |= __ios_base::failbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + __in._M_setstate(__ios_base::badbit); + throw; + } + catch(...) + { + + + + __in._M_setstate(__ios_base::badbit); + } + } + if (!__extracted) + __err |= __ios_base::failbit; + if (__err) + __in.setstate(__err); + return __in; + } + + + + + extern template class basic_string; + extern template + basic_istream& + operator>>(basic_istream&, string&); + extern template + basic_ostream& + operator<<(basic_ostream&, const string&); + extern template + basic_istream& + getline(basic_istream&, string&, char); + extern template + basic_istream& + getline(basic_istream&, string&); + + + extern template class basic_string; + extern template + basic_istream& + operator>>(basic_istream&, wstring&); + extern template + basic_ostream& + operator<<(basic_ostream&, const wstring&); + extern template + basic_istream& + getline(basic_istream&, wstring&, wchar_t); + extern template + basic_istream& + getline(basic_istream&, wstring&); + + + + +} +# 54 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 2 3 +# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 62 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + class locale + { + public: + + + typedef int category; + + + class facet; + class id; + class _Impl; + + friend class facet; + friend class _Impl; + + template + friend bool + has_facet(const locale&) throw(); + + template + friend const _Facet& + use_facet(const locale&); + + template + friend struct __use_cache; +# 98 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + static const category none = 0; + static const category ctype = 1L << 0; + static const category numeric = 1L << 1; + static const category collate = 1L << 2; + static const category time = 1L << 3; + static const category monetary = 1L << 4; + static const category messages = 1L << 5; + static const category all = (ctype | numeric | collate | + time | monetary | messages); +# 117 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + locale() throw(); +# 126 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + locale(const locale& __other) throw(); +# 136 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + explicit + locale(const char* __s); +# 151 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + locale(const locale& __base, const char* __s, category __cat); +# 162 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + explicit + locale(const std::string& __s) : locale(__s.c_str()) { } +# 177 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + locale(const locale& __base, const std::string& __s, category __cat) + : locale(__base, __s.c_str(), __cat) { } +# 192 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + locale(const locale& __base, const locale& __add, category __cat); +# 205 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + template + locale(const locale& __other, _Facet* __f); + + + ~locale() throw(); +# 219 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + const locale& + operator=(const locale& __other) throw(); +# 234 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + template + locale + combine(const locale& __other) const; + + + + + + + __attribute ((__abi_tag__ ("cxx11"))) + string + name() const; +# 254 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + bool + operator==(const locale& __other) const throw(); + + + + + + + + bool + operator!=(const locale& __other) const throw() + { return !(this->operator==(__other)); } +# 282 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + template + bool + operator()(const basic_string<_Char, _Traits, _Alloc>& __s1, + const basic_string<_Char, _Traits, _Alloc>& __s2) const; +# 298 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + static locale + global(const locale& __loc); + + + + + static const locale& + classic(); + + private: + + _Impl* _M_impl; + + + static _Impl* _S_classic; + + + static _Impl* _S_global; + + + + + + static const char* const* const _S_categories; +# 333 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + enum { _S_categories_size = 6 + 6 }; + + + static __gthread_once_t _S_once; + + + explicit + locale(_Impl*) throw(); + + static void + _S_initialize(); + + static void + _S_initialize_once() throw(); + + static category + _S_normalize_category(category); + + void + _M_coalesce(const locale& __base, const locale& __add, category __cat); + + + static const id* const _S_twinned_facets[]; + + }; +# 371 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + class locale::facet + { + private: + friend class locale; + friend class locale::_Impl; + + mutable _Atomic_word _M_refcount; + + + static __c_locale _S_c_locale; + + + static const char _S_c_name[2]; + + + static __gthread_once_t _S_once; + + + static void + _S_initialize_once(); + + protected: +# 402 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + explicit + facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0) + { } + + + virtual + ~facet(); + + static void + _S_create_c_locale(__c_locale& __cloc, const char* __s, + __c_locale __old = 0); + + static __c_locale + _S_clone_c_locale(__c_locale& __cloc) throw(); + + static void + _S_destroy_c_locale(__c_locale& __cloc); + + static __c_locale + _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s); + + + + static __c_locale + _S_get_c_locale(); + + __attribute__ ((__const__)) static const char* + _S_get_c_name() throw(); +# 438 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + facet(const facet&) = delete; + + facet& + operator=(const facet&) = delete; + + + private: + void + _M_add_reference() const throw() + { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); } + + void + _M_remove_reference() const throw() + { + + ; + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1) + { + ; + try + { delete this; } + catch(...) + { } + } + } + + class __shim; + + const facet* _M_sso_shim(const id*) const; + const facet* _M_cow_shim(const id*) const; + }; +# 482 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + class locale::id + { + private: + friend class locale; + friend class locale::_Impl; + + template + friend const _Facet& + use_facet(const locale&); + + template + friend bool + has_facet(const locale&) throw(); + + + + + mutable size_t _M_index; + + + static _Atomic_word _S_refcount; + + void + operator=(const id&); + + id(const id&); + + public: + + + + id() { } + + size_t + _M_id() const throw(); + }; + + + + class locale::_Impl + { + public: + + friend class locale; + friend class locale::facet; + + template + friend bool + has_facet(const locale&) throw(); + + template + friend const _Facet& + use_facet(const locale&); + + template + friend struct __use_cache; + + private: + + _Atomic_word _M_refcount; + const facet** _M_facets; + size_t _M_facets_size; + const facet** _M_caches; + char** _M_names; + static const locale::id* const _S_id_ctype[]; + static const locale::id* const _S_id_numeric[]; + static const locale::id* const _S_id_collate[]; + static const locale::id* const _S_id_time[]; + static const locale::id* const _S_id_monetary[]; + static const locale::id* const _S_id_messages[]; + static const locale::id* const* const _S_facet_categories[]; + + void + _M_add_reference() throw() + { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); } + + void + _M_remove_reference() throw() + { + + ; + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1) + { + ; + try + { delete this; } + catch(...) + { } + } + } + + _Impl(const _Impl&, size_t); + _Impl(const char*, size_t); + _Impl(size_t) throw(); + + ~_Impl() throw(); + + _Impl(const _Impl&); + + void + operator=(const _Impl&); + + bool + _M_check_same_name() + { + bool __ret = true; + if (_M_names[1]) + + for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i) + __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0; + return __ret; + } + + void + _M_replace_categories(const _Impl*, category); + + void + _M_replace_category(const _Impl*, const locale::id* const*); + + void + _M_replace_facet(const _Impl*, const locale::id*); + + void + _M_install_facet(const locale::id*, const facet*); + + template + void + _M_init_facet(_Facet* __facet) + { _M_install_facet(&_Facet::id, __facet); } + + template + void + _M_init_facet_unchecked(_Facet* __facet) + { + __facet->_M_add_reference(); + _M_facets[_Facet::id._M_id()] = __facet; + } + + void + _M_install_cache(const facet*, size_t); + + void _M_init_extra(facet**); + void _M_init_extra(void*, void*, const char*, const char*); + }; +# 640 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + template + class __cxx11:: collate : public locale::facet + { + public: + + + + typedef _CharT char_type; + typedef basic_string<_CharT> string_type; + + + protected: + + + __c_locale _M_c_locale_collate; + + public: + + static locale::id id; +# 667 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + explicit + collate(size_t __refs = 0) + : facet(__refs), _M_c_locale_collate(_S_get_c_locale()) + { } +# 681 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + explicit + collate(__c_locale __cloc, size_t __refs = 0) + : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc)) + { } +# 698 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + int + compare(const _CharT* __lo1, const _CharT* __hi1, + const _CharT* __lo2, const _CharT* __hi2) const + { return this->do_compare(__lo1, __hi1, __lo2, __hi2); } +# 717 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + string_type + transform(const _CharT* __lo, const _CharT* __hi) const + { return this->do_transform(__lo, __hi); } +# 731 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + long + hash(const _CharT* __lo, const _CharT* __hi) const + { return this->do_hash(__lo, __hi); } + + + int + _M_compare(const _CharT*, const _CharT*) const throw(); + + size_t + _M_transform(_CharT*, const _CharT*, size_t) const throw(); + + protected: + + virtual + ~collate() + { _S_destroy_c_locale(_M_c_locale_collate); } +# 760 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + virtual int + do_compare(const _CharT* __lo1, const _CharT* __hi1, + const _CharT* __lo2, const _CharT* __hi2) const; +# 774 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + virtual string_type + do_transform(const _CharT* __lo, const _CharT* __hi) const; +# 787 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3 + virtual long + do_hash(const _CharT* __lo, const _CharT* __hi) const; + }; + + template + locale::id collate<_CharT>::id; + + + template<> + int + collate::_M_compare(const char*, const char*) const throw(); + + template<> + size_t + collate::_M_transform(char*, const char*, size_t) const throw(); + + + template<> + int + collate::_M_compare(const wchar_t*, const wchar_t*) const throw(); + + template<> + size_t + collate::_M_transform(wchar_t*, const wchar_t*, size_t) const throw(); + + + + template + class __cxx11:: collate_byname : public collate<_CharT> + { + public: + + + typedef _CharT char_type; + typedef basic_string<_CharT> string_type; + + + explicit + collate_byname(const char* __s, size_t __refs = 0) + : collate<_CharT>(__refs) + { + if (__builtin_strcmp(__s, "C") != 0 + && __builtin_strcmp(__s, "POSIX") != 0) + { + this->_S_destroy_c_locale(this->_M_c_locale_collate); + this->_S_create_c_locale(this->_M_c_locale_collate, __s); + } + } + + + explicit + collate_byname(const string& __s, size_t __refs = 0) + : collate_byname(__s.c_str(), __refs) { } + + + protected: + virtual + ~collate_byname() { } + }; + + +} + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.tcc" 1 3 +# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.tcc" 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + locale:: + locale(const locale& __other, _Facet* __f) + { + _M_impl = new _Impl(*__other._M_impl, 1); + + try + { _M_impl->_M_install_facet(&_Facet::id, __f); } + catch(...) + { + _M_impl->_M_remove_reference(); + throw; + } + delete [] _M_impl->_M_names[0]; + _M_impl->_M_names[0] = 0; + } + + template + locale + locale:: + combine(const locale& __other) const + { + _Impl* __tmp = new _Impl(*_M_impl, 1); + try + { + __tmp->_M_replace_facet(__other._M_impl, &_Facet::id); + } + catch(...) + { + __tmp->_M_remove_reference(); + throw; + } + return locale(__tmp); + } + + template + bool + locale:: + operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1, + const basic_string<_CharT, _Traits, _Alloc>& __s2) const + { + typedef std::collate<_CharT> __collate_type; + const __collate_type& __collate = use_facet<__collate_type>(*this); + return (__collate.compare(__s1.data(), __s1.data() + __s1.length(), + __s2.data(), __s2.data() + __s2.length()) < 0); + } +# 102 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.tcc" 3 + template + bool + has_facet(const locale& __loc) throw() + { + const size_t __i = _Facet::id._M_id(); + const locale::facet** __facets = __loc._M_impl->_M_facets; + return (__i < __loc._M_impl->_M_facets_size + + && dynamic_cast(__facets[__i])); + + + + } +# 130 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.tcc" 3 + template + const _Facet& + use_facet(const locale& __loc) + { + const size_t __i = _Facet::id._M_id(); + const locale::facet** __facets = __loc._M_impl->_M_facets; + if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i]) + __throw_bad_cast(); + + return dynamic_cast(*__facets[__i]); + + + + } + + + + template + int + collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw () + { return 0; } + + + template + size_t + collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw () + { return 0; } + + template + int + collate<_CharT>:: + do_compare(const _CharT* __lo1, const _CharT* __hi1, + const _CharT* __lo2, const _CharT* __hi2) const + { + + + const string_type __one(__lo1, __hi1); + const string_type __two(__lo2, __hi2); + + const _CharT* __p = __one.c_str(); + const _CharT* __pend = __one.data() + __one.length(); + const _CharT* __q = __two.c_str(); + const _CharT* __qend = __two.data() + __two.length(); + + + + + for (;;) + { + const int __res = _M_compare(__p, __q); + if (__res) + return __res; + + __p += char_traits<_CharT>::length(__p); + __q += char_traits<_CharT>::length(__q); + if (__p == __pend && __q == __qend) + return 0; + else if (__p == __pend) + return -1; + else if (__q == __qend) + return 1; + + __p++; + __q++; + } + } + + template + typename collate<_CharT>::string_type + collate<_CharT>:: + do_transform(const _CharT* __lo, const _CharT* __hi) const + { + string_type __ret; + + + const string_type __str(__lo, __hi); + + const _CharT* __p = __str.c_str(); + const _CharT* __pend = __str.data() + __str.length(); + + size_t __len = (__hi - __lo) * 2; + + _CharT* __c = new _CharT[__len]; + + try + { + + + + for (;;) + { + + size_t __res = _M_transform(__c, __p, __len); + + + if (__res >= __len) + { + __len = __res + 1; + delete [] __c, __c = 0; + __c = new _CharT[__len]; + __res = _M_transform(__c, __p, __len); + } + + __ret.append(__c, __res); + __p += char_traits<_CharT>::length(__p); + if (__p == __pend) + break; + + __p++; + __ret.push_back(_CharT()); + } + } + catch(...) + { + delete [] __c; + throw; + } + + delete [] __c; + + return __ret; + } + + template + long + collate<_CharT>:: + do_hash(const _CharT* __lo, const _CharT* __hi) const + { + unsigned long __val = 0; + for (; __lo < __hi; ++__lo) + __val = + *__lo + ((__val << 7) + | (__val >> (__gnu_cxx::__numeric_traits:: + __digits - 7))); + return static_cast(__val); + } + + + + + extern template class collate; + extern template class collate_byname; + + extern template + const collate& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + + extern template class collate; + extern template class collate_byname; + + extern template + const collate& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + + + +} +# 851 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 2 3 +# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 2 3 + + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/system_error" 1 3 +# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/system_error" 3 + + + + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/error_constants.h" 1 3 +# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/error_constants.h" 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cerrno" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cerrno" 3 + + +# 1 "/usr/include/errno.h" 1 3 4 +# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cerrno" 2 3 +# 35 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/error_constants.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + enum class errc + { + address_family_not_supported = 97, + address_in_use = 98, + address_not_available = 99, + already_connected = 106, + argument_list_too_long = 7, + argument_out_of_domain = 33, + bad_address = 14, + bad_file_descriptor = 9, + + + bad_message = 74, + + + broken_pipe = 32, + connection_aborted = 103, + connection_already_in_progress = 114, + connection_refused = 111, + connection_reset = 104, + cross_device_link = 18, + destination_address_required = 89, + device_or_resource_busy = 16, + directory_not_empty = 39, + executable_format_error = 8, + file_exists = 17, + file_too_large = 27, + filename_too_long = 36, + function_not_supported = 38, + host_unreachable = 113, + + + identifier_removed = 43, + + + illegal_byte_sequence = 84, + inappropriate_io_control_operation = 25, + interrupted = 4, + invalid_argument = 22, + invalid_seek = 29, + io_error = 5, + is_a_directory = 21, + message_size = 90, + network_down = 100, + network_reset = 102, + network_unreachable = 101, + no_buffer_space = 105, + no_child_process = 10, + + + no_link = 67, + + + no_lock_available = 37, + + + no_message_available = 61, + + + no_message = 42, + no_protocol_option = 92, + no_space_on_device = 28, + + + no_stream_resources = 63, + + + no_such_device_or_address = 6, + no_such_device = 19, + no_such_file_or_directory = 2, + no_such_process = 3, + not_a_directory = 20, + not_a_socket = 88, + + + not_a_stream = 60, + + + not_connected = 107, + not_enough_memory = 12, + + + not_supported = 95, + + + + operation_canceled = 125, + + + operation_in_progress = 115, + operation_not_permitted = 1, + operation_not_supported = 95, + operation_would_block = 11, + + + owner_dead = 130, + + + permission_denied = 13, + + + protocol_error = 71, + + + protocol_not_supported = 93, + read_only_file_system = 30, + resource_deadlock_would_occur = 35, + resource_unavailable_try_again = 11, + result_out_of_range = 34, + + + state_not_recoverable = 131, + + + + stream_timeout = 62, + + + + text_file_busy = 26, + + + timed_out = 110, + too_many_files_open_in_system = 23, + too_many_files_open = 24, + too_many_links = 31, + too_many_symbolic_link_levels = 40, + + + value_too_large = 75, + + + wrong_protocol_type = 91 + }; + + +} +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/system_error" 2 3 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdexcept" 1 3 +# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdexcept" 3 + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + struct __cow_string + { + union { + const char* _M_p; + char _M_bytes[sizeof(const char*)]; + }; + + __cow_string(); + __cow_string(const std::string&); + __cow_string(const char*, size_t); + __cow_string(const __cow_string&) noexcept; + __cow_string& operator=(const __cow_string&) noexcept; + ~__cow_string(); + + __cow_string(__cow_string&&) noexcept; + __cow_string& operator=(__cow_string&&) noexcept; + + }; + + typedef basic_string __sso_string; +# 113 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdexcept" 3 + class logic_error : public exception + { + __cow_string _M_msg; + + public: + + explicit + logic_error(const string& __arg) ; + + + explicit + logic_error(const char*) ; + + + + logic_error(const logic_error&) noexcept; + logic_error& operator=(const logic_error&) noexcept; + + + virtual ~logic_error() noexcept; + + + + virtual const char* + what() const noexcept; + + + + + + }; + + + + class domain_error : public logic_error + { + public: + explicit domain_error(const string& __arg) ; + + explicit domain_error(const char*) ; + + virtual ~domain_error() noexcept; + }; + + + class invalid_argument : public logic_error + { + public: + explicit invalid_argument(const string& __arg) ; + + explicit invalid_argument(const char*) ; + + virtual ~invalid_argument() noexcept; + }; + + + + class length_error : public logic_error + { + public: + explicit length_error(const string& __arg) ; + + explicit length_error(const char*) ; + + virtual ~length_error() noexcept; + }; + + + + class out_of_range : public logic_error + { + public: + explicit out_of_range(const string& __arg) ; + + explicit out_of_range(const char*) ; + + virtual ~out_of_range() noexcept; + }; + + + + + + + class runtime_error : public exception + { + __cow_string _M_msg; + + public: + + explicit + runtime_error(const string& __arg) ; + + + explicit + runtime_error(const char*) ; + + + + runtime_error(const runtime_error&) noexcept; + runtime_error& operator=(const runtime_error&) noexcept; + + + virtual ~runtime_error() noexcept; + + + + virtual const char* + what() const noexcept; + + + + + + }; + + + class range_error : public runtime_error + { + public: + explicit range_error(const string& __arg) ; + + explicit range_error(const char*) ; + + virtual ~range_error() noexcept; + }; + + + class overflow_error : public runtime_error + { + public: + explicit overflow_error(const string& __arg) ; + + explicit overflow_error(const char*) ; + + virtual ~overflow_error() noexcept; + }; + + + class underflow_error : public runtime_error + { + public: + explicit underflow_error(const string& __arg) ; + + explicit underflow_error(const char*) ; + + virtual ~underflow_error() noexcept; + }; + + + + +} +# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/system_error" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + class error_code; + class error_condition; + class system_error; + + + template + struct is_error_code_enum : public false_type { }; + + + template + struct is_error_condition_enum : public false_type { }; + + template<> + struct is_error_condition_enum + : public true_type { }; + + inline namespace _V2 { + + + class error_category + { + public: + constexpr error_category() noexcept = default; + + virtual ~error_category(); + + error_category(const error_category&) = delete; + error_category& operator=(const error_category&) = delete; + + virtual const char* + name() const noexcept = 0; + + + + + + + private: + __attribute ((__abi_tag__ ("cxx11"))) + virtual __cow_string + _M_message(int) const; + + public: + __attribute ((__abi_tag__ ("cxx11"))) + virtual string + message(int) const = 0; +# 102 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/system_error" 3 + public: + virtual error_condition + default_error_condition(int __i) const noexcept; + + virtual bool + equivalent(int __i, const error_condition& __cond) const noexcept; + + virtual bool + equivalent(const error_code& __code, int __i) const noexcept; + + bool + operator<(const error_category& __other) const noexcept + { return less()(this, &__other); } + + bool + operator==(const error_category& __other) const noexcept + { return this == &__other; } + + bool + operator!=(const error_category& __other) const noexcept + { return this != &__other; } + }; + + + __attribute__ ((__const__)) const error_category& system_category() noexcept; + __attribute__ ((__const__)) const error_category& generic_category() noexcept; + + } + + error_code make_error_code(errc) noexcept; + + template + struct hash; + + + + struct error_code + { + error_code() noexcept + : _M_value(0), _M_cat(&system_category()) { } + + error_code(int __v, const error_category& __cat) noexcept + : _M_value(__v), _M_cat(&__cat) { } + + template::value>::type> + error_code(_ErrorCodeEnum __e) noexcept + { *this = make_error_code(__e); } + + void + assign(int __v, const error_category& __cat) noexcept + { + _M_value = __v; + _M_cat = &__cat; + } + + void + clear() noexcept + { assign(0, system_category()); } + + + template + typename enable_if::value, + error_code&>::type + operator=(_ErrorCodeEnum __e) noexcept + { return *this = make_error_code(__e); } + + int + value() const noexcept { return _M_value; } + + const error_category& + category() const noexcept { return *_M_cat; } + + error_condition + default_error_condition() const noexcept; + + __attribute ((__abi_tag__ ("cxx11"))) + string + message() const + { return category().message(value()); } + + explicit operator bool() const noexcept + { return _M_value != 0; } + + + private: + friend class hash; + + int _M_value; + const error_category* _M_cat; + }; + + + inline error_code + make_error_code(errc __e) noexcept + { return error_code(static_cast(__e), generic_category()); } + + inline bool + operator<(const error_code& __lhs, const error_code& __rhs) noexcept + { + return (__lhs.category() < __rhs.category() + || (__lhs.category() == __rhs.category() + && __lhs.value() < __rhs.value())); + } + + template + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e) + { return (__os << __e.category().name() << ':' << __e.value()); } + + error_condition make_error_condition(errc) noexcept; + + + + struct error_condition + { + error_condition() noexcept + : _M_value(0), _M_cat(&generic_category()) { } + + error_condition(int __v, const error_category& __cat) noexcept + : _M_value(__v), _M_cat(&__cat) { } + + template::value>::type> + error_condition(_ErrorConditionEnum __e) noexcept + { *this = make_error_condition(__e); } + + void + assign(int __v, const error_category& __cat) noexcept + { + _M_value = __v; + _M_cat = &__cat; + } + + + template + typename enable_if::value, error_condition&>::type + operator=(_ErrorConditionEnum __e) noexcept + { return *this = make_error_condition(__e); } + + void + clear() noexcept + { assign(0, generic_category()); } + + + int + value() const noexcept { return _M_value; } + + const error_category& + category() const noexcept { return *_M_cat; } + + __attribute ((__abi_tag__ ("cxx11"))) + string + message() const + { return category().message(value()); } + + explicit operator bool() const noexcept + { return _M_value != 0; } + + + private: + int _M_value; + const error_category* _M_cat; + }; + + + inline error_condition + make_error_condition(errc __e) noexcept + { return error_condition(static_cast(__e), generic_category()); } + + inline bool + operator<(const error_condition& __lhs, + const error_condition& __rhs) noexcept + { + return (__lhs.category() < __rhs.category() + || (__lhs.category() == __rhs.category() + && __lhs.value() < __rhs.value())); + } + + + inline bool + operator==(const error_code& __lhs, const error_code& __rhs) noexcept + { return (__lhs.category() == __rhs.category() + && __lhs.value() == __rhs.value()); } + + inline bool + operator==(const error_code& __lhs, const error_condition& __rhs) noexcept + { + return (__lhs.category().equivalent(__lhs.value(), __rhs) + || __rhs.category().equivalent(__lhs, __rhs.value())); + } + + inline bool + operator==(const error_condition& __lhs, const error_code& __rhs) noexcept + { + return (__rhs.category().equivalent(__rhs.value(), __lhs) + || __lhs.category().equivalent(__rhs, __lhs.value())); + } + + inline bool + operator==(const error_condition& __lhs, + const error_condition& __rhs) noexcept + { + return (__lhs.category() == __rhs.category() + && __lhs.value() == __rhs.value()); + } + + inline bool + operator!=(const error_code& __lhs, const error_code& __rhs) noexcept + { return !(__lhs == __rhs); } + + inline bool + operator!=(const error_code& __lhs, const error_condition& __rhs) noexcept + { return !(__lhs == __rhs); } + + inline bool + operator!=(const error_condition& __lhs, const error_code& __rhs) noexcept + { return !(__lhs == __rhs); } + + inline bool + operator!=(const error_condition& __lhs, + const error_condition& __rhs) noexcept + { return !(__lhs == __rhs); } + + + + + + + + class system_error : public std::runtime_error + { + private: + error_code _M_code; + + public: + system_error(error_code __ec = error_code()) + : runtime_error(__ec.message()), _M_code(__ec) { } + + system_error(error_code __ec, const string& __what) + : runtime_error(__what + ": " + __ec.message()), _M_code(__ec) { } + + system_error(error_code __ec, const char* __what) + : runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { } + + system_error(int __v, const error_category& __ecat, const char* __what) + : system_error(error_code(__v, __ecat), __what) { } + + system_error(int __v, const error_category& __ecat) + : runtime_error(error_code(__v, __ecat).message()), + _M_code(__v, __ecat) { } + + system_error(int __v, const error_category& __ecat, const string& __what) + : runtime_error(__what + ": " + error_code(__v, __ecat).message()), + _M_code(__v, __ecat) { } + + virtual ~system_error() noexcept; + + const error_code& + code() const noexcept { return _M_code; } + }; + + +} + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template<> + struct hash + : public __hash_base + { + size_t + operator()(const error_code& __e) const noexcept + { + const size_t __tmp = std::_Hash_impl::hash(__e._M_value); + return std::_Hash_impl::__hash_combine(__e._M_cat, __tmp); + } + }; + + +} +# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + enum _Ios_Fmtflags + { + _S_boolalpha = 1L << 0, + _S_dec = 1L << 1, + _S_fixed = 1L << 2, + _S_hex = 1L << 3, + _S_internal = 1L << 4, + _S_left = 1L << 5, + _S_oct = 1L << 6, + _S_right = 1L << 7, + _S_scientific = 1L << 8, + _S_showbase = 1L << 9, + _S_showpoint = 1L << 10, + _S_showpos = 1L << 11, + _S_skipws = 1L << 12, + _S_unitbuf = 1L << 13, + _S_uppercase = 1L << 14, + _S_adjustfield = _S_left | _S_right | _S_internal, + _S_basefield = _S_dec | _S_oct | _S_hex, + _S_floatfield = _S_scientific | _S_fixed, + _S_ios_fmtflags_end = 1L << 16, + _S_ios_fmtflags_max = 2147483647, + _S_ios_fmtflags_min = ~2147483647 + }; + + inline constexpr _Ios_Fmtflags + operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b) + { return _Ios_Fmtflags(static_cast(__a) & static_cast(__b)); } + + inline constexpr _Ios_Fmtflags + operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b) + { return _Ios_Fmtflags(static_cast(__a) | static_cast(__b)); } + + inline constexpr _Ios_Fmtflags + operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b) + { return _Ios_Fmtflags(static_cast(__a) ^ static_cast(__b)); } + + inline constexpr _Ios_Fmtflags + operator~(_Ios_Fmtflags __a) + { return _Ios_Fmtflags(~static_cast(__a)); } + + inline const _Ios_Fmtflags& + operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) + { return __a = __a | __b; } + + inline const _Ios_Fmtflags& + operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) + { return __a = __a & __b; } + + inline const _Ios_Fmtflags& + operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) + { return __a = __a ^ __b; } + + + enum _Ios_Openmode + { + _S_app = 1L << 0, + _S_ate = 1L << 1, + _S_bin = 1L << 2, + _S_in = 1L << 3, + _S_out = 1L << 4, + _S_trunc = 1L << 5, + _S_ios_openmode_end = 1L << 16, + _S_ios_openmode_max = 2147483647, + _S_ios_openmode_min = ~2147483647 + }; + + inline constexpr _Ios_Openmode + operator&(_Ios_Openmode __a, _Ios_Openmode __b) + { return _Ios_Openmode(static_cast(__a) & static_cast(__b)); } + + inline constexpr _Ios_Openmode + operator|(_Ios_Openmode __a, _Ios_Openmode __b) + { return _Ios_Openmode(static_cast(__a) | static_cast(__b)); } + + inline constexpr _Ios_Openmode + operator^(_Ios_Openmode __a, _Ios_Openmode __b) + { return _Ios_Openmode(static_cast(__a) ^ static_cast(__b)); } + + inline constexpr _Ios_Openmode + operator~(_Ios_Openmode __a) + { return _Ios_Openmode(~static_cast(__a)); } + + inline const _Ios_Openmode& + operator|=(_Ios_Openmode& __a, _Ios_Openmode __b) + { return __a = __a | __b; } + + inline const _Ios_Openmode& + operator&=(_Ios_Openmode& __a, _Ios_Openmode __b) + { return __a = __a & __b; } + + inline const _Ios_Openmode& + operator^=(_Ios_Openmode& __a, _Ios_Openmode __b) + { return __a = __a ^ __b; } + + + enum _Ios_Iostate + { + _S_goodbit = 0, + _S_badbit = 1L << 0, + _S_eofbit = 1L << 1, + _S_failbit = 1L << 2, + _S_ios_iostate_end = 1L << 16, + _S_ios_iostate_max = 2147483647, + _S_ios_iostate_min = ~2147483647 + }; + + inline constexpr _Ios_Iostate + operator&(_Ios_Iostate __a, _Ios_Iostate __b) + { return _Ios_Iostate(static_cast(__a) & static_cast(__b)); } + + inline constexpr _Ios_Iostate + operator|(_Ios_Iostate __a, _Ios_Iostate __b) + { return _Ios_Iostate(static_cast(__a) | static_cast(__b)); } + + inline constexpr _Ios_Iostate + operator^(_Ios_Iostate __a, _Ios_Iostate __b) + { return _Ios_Iostate(static_cast(__a) ^ static_cast(__b)); } + + inline constexpr _Ios_Iostate + operator~(_Ios_Iostate __a) + { return _Ios_Iostate(~static_cast(__a)); } + + inline const _Ios_Iostate& + operator|=(_Ios_Iostate& __a, _Ios_Iostate __b) + { return __a = __a | __b; } + + inline const _Ios_Iostate& + operator&=(_Ios_Iostate& __a, _Ios_Iostate __b) + { return __a = __a & __b; } + + inline const _Ios_Iostate& + operator^=(_Ios_Iostate& __a, _Ios_Iostate __b) + { return __a = __a ^ __b; } + + + enum _Ios_Seekdir + { + _S_beg = 0, + _S_cur = 1, + _S_end = 2, + _S_ios_seekdir_end = 1L << 16 + }; + + + + enum class io_errc { stream = 1 }; + + template <> struct is_error_code_enum : public true_type { }; + + const error_category& iostream_category() noexcept; + + inline error_code + make_error_code(io_errc e) noexcept + { return error_code(static_cast(e), iostream_category()); } + + inline error_condition + make_error_condition(io_errc e) noexcept + { return error_condition(static_cast(e), iostream_category()); } +# 228 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + class ios_base + { +# 246 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + public: +# 255 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + class __attribute ((__abi_tag__ ("cxx11"))) failure : public system_error + { + public: + explicit + failure(const string& __str); + + + explicit + failure(const string&, const error_code&); + + explicit + failure(const char*, const error_code& = io_errc::stream); + + + virtual + ~failure() throw(); + + virtual const char* + what() const throw(); + }; +# 323 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + typedef _Ios_Fmtflags fmtflags; + + + static const fmtflags boolalpha = _S_boolalpha; + + + static const fmtflags dec = _S_dec; + + + static const fmtflags fixed = _S_fixed; + + + static const fmtflags hex = _S_hex; + + + + + static const fmtflags internal = _S_internal; + + + + static const fmtflags left = _S_left; + + + static const fmtflags oct = _S_oct; + + + + static const fmtflags right = _S_right; + + + static const fmtflags scientific = _S_scientific; + + + + static const fmtflags showbase = _S_showbase; + + + + static const fmtflags showpoint = _S_showpoint; + + + static const fmtflags showpos = _S_showpos; + + + static const fmtflags skipws = _S_skipws; + + + static const fmtflags unitbuf = _S_unitbuf; + + + + static const fmtflags uppercase = _S_uppercase; + + + static const fmtflags adjustfield = _S_adjustfield; + + + static const fmtflags basefield = _S_basefield; + + + static const fmtflags floatfield = _S_floatfield; +# 398 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + typedef _Ios_Iostate iostate; + + + + static const iostate badbit = _S_badbit; + + + static const iostate eofbit = _S_eofbit; + + + + + static const iostate failbit = _S_failbit; + + + static const iostate goodbit = _S_goodbit; +# 429 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + typedef _Ios_Openmode openmode; + + + static const openmode app = _S_app; + + + static const openmode ate = _S_ate; + + + + + static const openmode binary = _S_bin; + + + static const openmode in = _S_in; + + + static const openmode out = _S_out; + + + static const openmode trunc = _S_trunc; +# 461 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + typedef _Ios_Seekdir seekdir; + + + static const seekdir beg = _S_beg; + + + static const seekdir cur = _S_cur; + + + static const seekdir end = _S_end; + + + typedef int io_state; + typedef int open_mode; + typedef int seek_dir; + + typedef std::streampos streampos; + typedef std::streamoff streamoff; +# 487 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + enum event + { + erase_event, + imbue_event, + copyfmt_event + }; +# 504 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + typedef void (*event_callback) (event __e, ios_base& __b, int __i); +# 516 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + void + register_callback(event_callback __fn, int __index); + + protected: + streamsize _M_precision; + streamsize _M_width; + fmtflags _M_flags; + iostate _M_exception; + iostate _M_streambuf_state; + + + + struct _Callback_list + { + + _Callback_list* _M_next; + ios_base::event_callback _M_fn; + int _M_index; + _Atomic_word _M_refcount; + + _Callback_list(ios_base::event_callback __fn, int __index, + _Callback_list* __cb) + : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { } + + void + _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); } + + + int + _M_remove_reference() + { + + ; + int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1); + if (__res == 0) + { + ; + } + return __res; + } + }; + + _Callback_list* _M_callbacks; + + void + _M_call_callbacks(event __ev) throw(); + + void + _M_dispose_callbacks(void) throw(); + + + struct _Words + { + void* _M_pword; + long _M_iword; + _Words() : _M_pword(0), _M_iword(0) { } + }; + + + _Words _M_word_zero; + + + + enum { _S_local_word_size = 8 }; + _Words _M_local_word[_S_local_word_size]; + + + int _M_word_size; + _Words* _M_word; + + _Words& + _M_grow_words(int __index, bool __iword); + + + locale _M_ios_locale; + + void + _M_init() throw(); + + public: + + + + + + class Init + { + friend class ios_base; + public: + Init(); + ~Init(); + + private: + static _Atomic_word _S_refcount; + static bool _S_synced_with_stdio; + }; + + + + + + + fmtflags + flags() const + { return _M_flags; } +# 629 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + fmtflags + flags(fmtflags __fmtfl) + { + fmtflags __old = _M_flags; + _M_flags = __fmtfl; + return __old; + } +# 645 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + fmtflags + setf(fmtflags __fmtfl) + { + fmtflags __old = _M_flags; + _M_flags |= __fmtfl; + return __old; + } +# 662 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + fmtflags + setf(fmtflags __fmtfl, fmtflags __mask) + { + fmtflags __old = _M_flags; + _M_flags &= ~__mask; + _M_flags |= (__fmtfl & __mask); + return __old; + } + + + + + + + + void + unsetf(fmtflags __mask) + { _M_flags &= ~__mask; } +# 688 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + streamsize + precision() const + { return _M_precision; } + + + + + + + streamsize + precision(streamsize __prec) + { + streamsize __old = _M_precision; + _M_precision = __prec; + return __old; + } + + + + + + + + streamsize + width() const + { return _M_width; } + + + + + + + streamsize + width(streamsize __wide) + { + streamsize __old = _M_width; + _M_width = __wide; + return __old; + } +# 739 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + static bool + sync_with_stdio(bool __sync = true); +# 751 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + locale + imbue(const locale& __loc) throw(); +# 762 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + locale + getloc() const + { return _M_ios_locale; } +# 773 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + const locale& + _M_getloc() const + { return _M_ios_locale; } +# 792 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + static int + xalloc() throw(); +# 808 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + long& + iword(int __ix) + { + _Words& __word = (__ix < _M_word_size) + ? _M_word[__ix] : _M_grow_words(__ix, true); + return __word._M_iword; + } +# 829 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + void*& + pword(int __ix) + { + _Words& __word = (__ix < _M_word_size) + ? _M_word[__ix] : _M_grow_words(__ix, false); + return __word._M_pword; + } +# 846 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + virtual ~ios_base(); + + protected: + ios_base() throw (); +# 860 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3 + public: + ios_base(const ios_base&) = delete; + + ios_base& + operator=(const ios_base&) = delete; + + protected: + void + _M_move(ios_base&) noexcept; + + void + _M_swap(ios_base& __rhs) noexcept; + + }; + + + + inline ios_base& + boolalpha(ios_base& __base) + { + __base.setf(ios_base::boolalpha); + return __base; + } + + + inline ios_base& + noboolalpha(ios_base& __base) + { + __base.unsetf(ios_base::boolalpha); + return __base; + } + + + inline ios_base& + showbase(ios_base& __base) + { + __base.setf(ios_base::showbase); + return __base; + } + + + inline ios_base& + noshowbase(ios_base& __base) + { + __base.unsetf(ios_base::showbase); + return __base; + } + + + inline ios_base& + showpoint(ios_base& __base) + { + __base.setf(ios_base::showpoint); + return __base; + } + + + inline ios_base& + noshowpoint(ios_base& __base) + { + __base.unsetf(ios_base::showpoint); + return __base; + } + + + inline ios_base& + showpos(ios_base& __base) + { + __base.setf(ios_base::showpos); + return __base; + } + + + inline ios_base& + noshowpos(ios_base& __base) + { + __base.unsetf(ios_base::showpos); + return __base; + } + + + inline ios_base& + skipws(ios_base& __base) + { + __base.setf(ios_base::skipws); + return __base; + } + + + inline ios_base& + noskipws(ios_base& __base) + { + __base.unsetf(ios_base::skipws); + return __base; + } + + + inline ios_base& + uppercase(ios_base& __base) + { + __base.setf(ios_base::uppercase); + return __base; + } + + + inline ios_base& + nouppercase(ios_base& __base) + { + __base.unsetf(ios_base::uppercase); + return __base; + } + + + inline ios_base& + unitbuf(ios_base& __base) + { + __base.setf(ios_base::unitbuf); + return __base; + } + + + inline ios_base& + nounitbuf(ios_base& __base) + { + __base.unsetf(ios_base::unitbuf); + return __base; + } + + + + inline ios_base& + internal(ios_base& __base) + { + __base.setf(ios_base::internal, ios_base::adjustfield); + return __base; + } + + + inline ios_base& + left(ios_base& __base) + { + __base.setf(ios_base::left, ios_base::adjustfield); + return __base; + } + + + inline ios_base& + right(ios_base& __base) + { + __base.setf(ios_base::right, ios_base::adjustfield); + return __base; + } + + + + inline ios_base& + dec(ios_base& __base) + { + __base.setf(ios_base::dec, ios_base::basefield); + return __base; + } + + + inline ios_base& + hex(ios_base& __base) + { + __base.setf(ios_base::hex, ios_base::basefield); + return __base; + } + + + inline ios_base& + oct(ios_base& __base) + { + __base.setf(ios_base::oct, ios_base::basefield); + return __base; + } + + + + inline ios_base& + fixed(ios_base& __base) + { + __base.setf(ios_base::fixed, ios_base::floatfield); + return __base; + } + + + inline ios_base& + scientific(ios_base& __base) + { + __base.setf(ios_base::scientific, ios_base::floatfield); + return __base; + } + + + + + + + inline ios_base& + hexfloat(ios_base& __base) + { + __base.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield); + return __base; + } + + + inline ios_base& + defaultfloat(ios_base& __base) + { + __base.unsetf(ios_base::floatfield); + return __base; + } + + + +} +# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 1 3 +# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + streamsize + __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*, + basic_streambuf<_CharT, _Traits>*, bool&); +# 119 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + template + class basic_streambuf + { + public: + + + + + + + typedef _CharT char_type; + typedef _Traits traits_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; + + + + + typedef basic_streambuf __streambuf_type; + + + friend class basic_ios; + friend class basic_istream; + friend class basic_ostream; + friend class istreambuf_iterator; + friend class ostreambuf_iterator; + + friend streamsize + __copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&); + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + _CharT2*>::__type + __copy_move_a2(istreambuf_iterator<_CharT2>, + istreambuf_iterator<_CharT2>, _CharT2*); + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + istreambuf_iterator<_CharT2> >::__type + find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, + const _CharT2&); + + template + friend basic_istream<_CharT2, _Traits2>& + operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*); + + template + friend basic_istream<_CharT2, _Traits2>& + operator>>(basic_istream<_CharT2, _Traits2>&, + basic_string<_CharT2, _Traits2, _Alloc>&); + + template + friend basic_istream<_CharT2, _Traits2>& + getline(basic_istream<_CharT2, _Traits2>&, + basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2); + + protected: + + + + + + + + char_type* _M_in_beg; + char_type* _M_in_cur; + char_type* _M_in_end; + char_type* _M_out_beg; + char_type* _M_out_cur; + char_type* _M_out_end; + + + locale _M_buf_locale; + + public: + + virtual + ~basic_streambuf() + { } +# 208 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + locale + pubimbue(const locale& __loc) + { + locale __tmp(this->getloc()); + this->imbue(__loc); + _M_buf_locale = __loc; + return __tmp; + } +# 225 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + locale + getloc() const + { return _M_buf_locale; } +# 238 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + basic_streambuf* + pubsetbuf(char_type* __s, streamsize __n) + { return this->setbuf(__s, __n); } +# 250 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + pos_type + pubseekoff(off_type __off, ios_base::seekdir __way, + ios_base::openmode __mode = ios_base::in | ios_base::out) + { return this->seekoff(__off, __way, __mode); } +# 262 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + pos_type + pubseekpos(pos_type __sp, + ios_base::openmode __mode = ios_base::in | ios_base::out) + { return this->seekpos(__sp, __mode); } + + + + + int + pubsync() { return this->sync(); } +# 283 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + streamsize + in_avail() + { + const streamsize __ret = this->egptr() - this->gptr(); + return __ret ? __ret : this->showmanyc(); + } +# 297 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + int_type + snextc() + { + int_type __ret = traits_type::eof(); + if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(), + __ret), true)) + __ret = this->sgetc(); + return __ret; + } +# 315 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + int_type + sbumpc() + { + int_type __ret; + if (__builtin_expect(this->gptr() < this->egptr(), true)) + { + __ret = traits_type::to_int_type(*this->gptr()); + this->gbump(1); + } + else + __ret = this->uflow(); + return __ret; + } +# 337 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + int_type + sgetc() + { + int_type __ret; + if (__builtin_expect(this->gptr() < this->egptr(), true)) + __ret = traits_type::to_int_type(*this->gptr()); + else + __ret = this->underflow(); + return __ret; + } +# 356 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + streamsize + sgetn(char_type* __s, streamsize __n) + { return this->xsgetn(__s, __n); } +# 371 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + int_type + sputbackc(char_type __c) + { + int_type __ret; + const bool __testpos = this->eback() < this->gptr(); + if (__builtin_expect(!__testpos || + !traits_type::eq(__c, this->gptr()[-1]), false)) + __ret = this->pbackfail(traits_type::to_int_type(__c)); + else + { + this->gbump(-1); + __ret = traits_type::to_int_type(*this->gptr()); + } + return __ret; + } +# 396 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + int_type + sungetc() + { + int_type __ret; + if (__builtin_expect(this->eback() < this->gptr(), true)) + { + this->gbump(-1); + __ret = traits_type::to_int_type(*this->gptr()); + } + else + __ret = this->pbackfail(); + return __ret; + } +# 423 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + int_type + sputc(char_type __c) + { + int_type __ret; + if (__builtin_expect(this->pptr() < this->epptr(), true)) + { + *this->pptr() = __c; + this->pbump(1); + __ret = traits_type::to_int_type(__c); + } + else + __ret = this->overflow(traits_type::to_int_type(__c)); + return __ret; + } +# 449 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + streamsize + sputn(const char_type* __s, streamsize __n) + { return this->xsputn(__s, __n); } + + protected: +# 463 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + basic_streambuf() + : _M_in_beg(0), _M_in_cur(0), _M_in_end(0), + _M_out_beg(0), _M_out_cur(0), _M_out_end(0), + _M_buf_locale(locale()) + { } +# 481 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + char_type* + eback() const { return _M_in_beg; } + + char_type* + gptr() const { return _M_in_cur; } + + char_type* + egptr() const { return _M_in_end; } +# 497 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + void + gbump(int __n) { _M_in_cur += __n; } +# 508 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + void + setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) + { + _M_in_beg = __gbeg; + _M_in_cur = __gnext; + _M_in_end = __gend; + } +# 528 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + char_type* + pbase() const { return _M_out_beg; } + + char_type* + pptr() const { return _M_out_cur; } + + char_type* + epptr() const { return _M_out_end; } +# 544 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + void + pbump(int __n) { _M_out_cur += __n; } +# 554 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + void + setp(char_type* __pbeg, char_type* __pend) + { + _M_out_beg = _M_out_cur = __pbeg; + _M_out_end = __pend; + } +# 575 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + virtual void + imbue(const locale& __loc) + { } +# 590 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + virtual basic_streambuf* + setbuf(char_type*, streamsize) + { return this; } +# 601 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + virtual pos_type + seekoff(off_type, ios_base::seekdir, + ios_base::openmode = ios_base::in | ios_base::out) + { return pos_type(off_type(-1)); } +# 613 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + virtual pos_type + seekpos(pos_type, + ios_base::openmode = ios_base::in | ios_base::out) + { return pos_type(off_type(-1)); } +# 626 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + virtual int + sync() { return 0; } +# 648 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + virtual streamsize + showmanyc() { return 0; } +# 664 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + virtual streamsize + xsgetn(char_type* __s, streamsize __n); +# 686 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + virtual int_type + underflow() + { return traits_type::eof(); } +# 699 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + virtual int_type + uflow() + { + int_type __ret = traits_type::eof(); + const bool __testeof = traits_type::eq_int_type(this->underflow(), + __ret); + if (!__testeof) + { + __ret = traits_type::to_int_type(*this->gptr()); + this->gbump(1); + } + return __ret; + } +# 723 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + virtual int_type + pbackfail(int_type __c = traits_type::eof()) + { return traits_type::eof(); } +# 741 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + virtual streamsize + xsputn(const char_type* __s, streamsize __n); +# 767 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + virtual int_type + overflow(int_type __c = traits_type::eof()) + { return traits_type::eof(); } + + + + public: +# 782 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3 + void + stossc() + { + if (this->gptr() < this->egptr()) + this->gbump(1); + else + this->uflow(); + } + + + + void + __safe_gbump(streamsize __n) { _M_in_cur += __n; } + + void + __safe_pbump(streamsize __n) { _M_out_cur += __n; } + + + + + protected: + + basic_streambuf(const basic_streambuf&); + + basic_streambuf& + operator=(const basic_streambuf&); + + + void + swap(basic_streambuf& __sb) + { + std::swap(_M_in_beg, __sb._M_in_beg); + std::swap(_M_in_cur, __sb._M_in_cur); + std::swap(_M_in_end, __sb._M_in_end); + std::swap(_M_out_beg, __sb._M_out_beg); + std::swap(_M_out_cur, __sb._M_out_cur); + std::swap(_M_out_end, __sb._M_out_end); + std::swap(_M_buf_locale, __sb._M_buf_locale); + } + + }; + + + template + std::basic_streambuf<_CharT, _Traits>:: + basic_streambuf(const basic_streambuf&) = default; + + template + std::basic_streambuf<_CharT, _Traits>& + std::basic_streambuf<_CharT, _Traits>:: + operator=(const basic_streambuf&) = default; + + + + template<> + streamsize + __copy_streambufs_eof(basic_streambuf* __sbin, + basic_streambuf* __sbout, bool& __ineof); + + template<> + streamsize + __copy_streambufs_eof(basic_streambuf* __sbin, + basic_streambuf* __sbout, bool& __ineof); + + + +} + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/streambuf.tcc" 1 3 +# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/streambuf.tcc" 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + streamsize + basic_streambuf<_CharT, _Traits>:: + xsgetn(char_type* __s, streamsize __n) + { + streamsize __ret = 0; + while (__ret < __n) + { + const streamsize __buf_len = this->egptr() - this->gptr(); + if (__buf_len) + { + const streamsize __remaining = __n - __ret; + const streamsize __len = std::min(__buf_len, __remaining); + traits_type::copy(__s, this->gptr(), __len); + __ret += __len; + __s += __len; + this->__safe_gbump(__len); + } + + if (__ret < __n) + { + const int_type __c = this->uflow(); + if (!traits_type::eq_int_type(__c, traits_type::eof())) + { + traits_type::assign(*__s++, traits_type::to_char_type(__c)); + ++__ret; + } + else + break; + } + } + return __ret; + } + + template + streamsize + basic_streambuf<_CharT, _Traits>:: + xsputn(const char_type* __s, streamsize __n) + { + streamsize __ret = 0; + while (__ret < __n) + { + const streamsize __buf_len = this->epptr() - this->pptr(); + if (__buf_len) + { + const streamsize __remaining = __n - __ret; + const streamsize __len = std::min(__buf_len, __remaining); + traits_type::copy(this->pptr(), __s, __len); + __ret += __len; + __s += __len; + this->__safe_pbump(__len); + } + + if (__ret < __n) + { + int_type __c = this->overflow(traits_type::to_int_type(*__s)); + if (!traits_type::eq_int_type(__c, traits_type::eof())) + { + ++__ret; + ++__s; + } + else + break; + } + } + return __ret; + } + + + + + template + streamsize + __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin, + basic_streambuf<_CharT, _Traits>* __sbout, + bool& __ineof) + { + streamsize __ret = 0; + __ineof = true; + typename _Traits::int_type __c = __sbin->sgetc(); + while (!_Traits::eq_int_type(__c, _Traits::eof())) + { + __c = __sbout->sputc(_Traits::to_char_type(__c)); + if (_Traits::eq_int_type(__c, _Traits::eof())) + { + __ineof = false; + break; + } + ++__ret; + __c = __sbin->snextc(); + } + return __ret; + } + + template + inline streamsize + __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin, + basic_streambuf<_CharT, _Traits>* __sbout) + { + bool __ineof; + return __copy_streambufs_eof(__sbin, __sbout, __ineof); + } + + + + + extern template class basic_streambuf; + extern template + streamsize + __copy_streambufs(basic_streambuf*, + basic_streambuf*); + extern template + streamsize + __copy_streambufs_eof(basic_streambuf*, + basic_streambuf*, bool&); + + + extern template class basic_streambuf; + extern template + streamsize + __copy_streambufs(basic_streambuf*, + basic_streambuf*); + extern template + streamsize + __copy_streambufs_eof(basic_streambuf*, + basic_streambuf*, bool&); + + + + +} +# 851 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 2 3 +# 44 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 1 3 +# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3 + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 1 3 +# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwctype" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwctype" 3 +# 50 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwctype" 3 +# 1 "/usr/include/wctype.h" 1 3 4 +# 33 "/usr/include/wctype.h" 3 4 +# 1 "/usr/include/wchar.h" 1 3 4 +# 34 "/usr/include/wctype.h" 2 3 4 +# 52 "/usr/include/wctype.h" 3 4 +typedef unsigned long int wctype_t; +# 71 "/usr/include/wctype.h" 3 4 +enum +{ + __ISwupper = 0, + __ISwlower = 1, + __ISwalpha = 2, + __ISwdigit = 3, + __ISwxdigit = 4, + __ISwspace = 5, + __ISwprint = 6, + __ISwgraph = 7, + __ISwblank = 8, + __ISwcntrl = 9, + __ISwpunct = 10, + __ISwalnum = 11, + + _ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))), + _ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))), + _ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))), + _ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))), + _ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))), + _ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))), + _ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))), + _ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))), + _ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))), + _ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))), + _ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))), + _ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24)))) +}; + + + +extern "C" { +# 111 "/usr/include/wctype.h" 3 4 +extern int iswalnum (wint_t __wc) throw (); + + + + + +extern int iswalpha (wint_t __wc) throw (); + + +extern int iswcntrl (wint_t __wc) throw (); + + + +extern int iswdigit (wint_t __wc) throw (); + + + +extern int iswgraph (wint_t __wc) throw (); + + + + +extern int iswlower (wint_t __wc) throw (); + + +extern int iswprint (wint_t __wc) throw (); + + + + +extern int iswpunct (wint_t __wc) throw (); + + + + +extern int iswspace (wint_t __wc) throw (); + + + + +extern int iswupper (wint_t __wc) throw (); + + + + +extern int iswxdigit (wint_t __wc) throw (); + + + + + +extern int iswblank (wint_t __wc) throw (); +# 171 "/usr/include/wctype.h" 3 4 +extern wctype_t wctype (const char *__property) throw (); + + + +extern int iswctype (wint_t __wc, wctype_t __desc) throw (); +# 186 "/usr/include/wctype.h" 3 4 +typedef const __int32_t *wctrans_t; + + + + + + + +extern wint_t towlower (wint_t __wc) throw (); + + +extern wint_t towupper (wint_t __wc) throw (); + + +} +# 213 "/usr/include/wctype.h" 3 4 +extern "C" { + + + + +extern wctrans_t wctrans (const char *__property) throw (); + + +extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw (); +# 230 "/usr/include/wctype.h" 3 4 +extern int iswalnum_l (wint_t __wc, __locale_t __locale) throw (); + + + + + +extern int iswalpha_l (wint_t __wc, __locale_t __locale) throw (); + + +extern int iswcntrl_l (wint_t __wc, __locale_t __locale) throw (); + + + +extern int iswdigit_l (wint_t __wc, __locale_t __locale) throw (); + + + +extern int iswgraph_l (wint_t __wc, __locale_t __locale) throw (); + + + + +extern int iswlower_l (wint_t __wc, __locale_t __locale) throw (); + + +extern int iswprint_l (wint_t __wc, __locale_t __locale) throw (); + + + + +extern int iswpunct_l (wint_t __wc, __locale_t __locale) throw (); + + + + +extern int iswspace_l (wint_t __wc, __locale_t __locale) throw (); + + + + +extern int iswupper_l (wint_t __wc, __locale_t __locale) throw (); + + + + +extern int iswxdigit_l (wint_t __wc, __locale_t __locale) throw (); + + + + +extern int iswblank_l (wint_t __wc, __locale_t __locale) throw (); + + + +extern wctype_t wctype_l (const char *__property, __locale_t __locale) + throw (); + + + +extern int iswctype_l (wint_t __wc, wctype_t __desc, __locale_t __locale) + throw (); + + + + + + + +extern wint_t towlower_l (wint_t __wc, __locale_t __locale) throw (); + + +extern wint_t towupper_l (wint_t __wc, __locale_t __locale) throw (); + + + +extern wctrans_t wctrans_l (const char *__property, __locale_t __locale) + throw (); + + +extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc, + __locale_t __locale) throw (); + + + +} +# 51 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwctype" 2 3 +# 80 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwctype" 3 +namespace std +{ + using ::wctrans_t; + using ::wctype_t; + using ::wint_t; + + using ::iswalnum; + using ::iswalpha; + + using ::iswblank; + + using ::iswcntrl; + using ::iswctype; + using ::iswdigit; + using ::iswgraph; + using ::iswlower; + using ::iswprint; + using ::iswpunct; + using ::iswspace; + using ::iswupper; + using ::iswxdigit; + using ::towctrans; + using ::towlower; + using ::towupper; + using ::wctrans; + using ::wctype; +} +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cctype" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cctype" 3 +# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/ctype_base.h" 1 3 +# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/ctype_base.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + struct ctype_base + { + + typedef const int* __to_type; + + + + typedef unsigned short mask; + static const mask upper = _ISupper; + static const mask lower = _ISlower; + static const mask alpha = _ISalpha; + static const mask digit = _ISdigit; + static const mask xdigit = _ISxdigit; + static const mask space = _ISspace; + static const mask print = _ISprint; + static const mask graph = _ISalpha | _ISdigit | _ISpunct; + static const mask cntrl = _IScntrl; + static const mask punct = _ISpunct; + static const mask alnum = _ISalpha | _ISdigit; + + static const mask blank = _ISblank; + + }; + + +} +# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 2 3 + + + + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/streambuf_iterator.h" 1 3 +# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/streambuf_iterator.h" 3 + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 49 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/streambuf_iterator.h" 3 + template + class istreambuf_iterator + : public iterator + + + + { + public: + + + + typedef _CharT char_type; + typedef _Traits traits_type; + typedef typename _Traits::int_type int_type; + typedef basic_streambuf<_CharT, _Traits> streambuf_type; + typedef basic_istream<_CharT, _Traits> istream_type; + + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + ostreambuf_iterator<_CharT2> >::__type + copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, + ostreambuf_iterator<_CharT2>); + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + _CharT2*>::__type + __copy_move_a2(istreambuf_iterator<_CharT2>, + istreambuf_iterator<_CharT2>, _CharT2*); + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + istreambuf_iterator<_CharT2> >::__type + find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, + const _CharT2&); + + private: + + + + + + + + mutable streambuf_type* _M_sbuf; + mutable int_type _M_c; + + public: + + constexpr istreambuf_iterator() noexcept + : _M_sbuf(0), _M_c(traits_type::eof()) { } + + + istreambuf_iterator(const istreambuf_iterator&) noexcept = default; + + ~istreambuf_iterator() = default; + + + + istreambuf_iterator(istream_type& __s) noexcept + : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { } + + + istreambuf_iterator(streambuf_type* __s) noexcept + : _M_sbuf(__s), _M_c(traits_type::eof()) { } + + + + + char_type + operator*() const + { + + + + + + + + return traits_type::to_char_type(_M_get()); + } + + + istreambuf_iterator& + operator++() + { + + + ; + if (_M_sbuf) + { + _M_sbuf->sbumpc(); + _M_c = traits_type::eof(); + } + return *this; + } + + + istreambuf_iterator + operator++(int) + { + + + ; + + istreambuf_iterator __old = *this; + if (_M_sbuf) + { + __old._M_c = _M_sbuf->sbumpc(); + _M_c = traits_type::eof(); + } + return __old; + } + + + + + + bool + equal(const istreambuf_iterator& __b) const + { return _M_at_eof() == __b._M_at_eof(); } + + private: + int_type + _M_get() const + { + const int_type __eof = traits_type::eof(); + int_type __ret = __eof; + if (_M_sbuf) + { + if (!traits_type::eq_int_type(_M_c, __eof)) + __ret = _M_c; + else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()), + __eof)) + _M_c = __ret; + else + _M_sbuf = 0; + } + return __ret; + } + + bool + _M_at_eof() const + { + const int_type __eof = traits_type::eof(); + return traits_type::eq_int_type(_M_get(), __eof); + } + }; + + template + inline bool + operator==(const istreambuf_iterator<_CharT, _Traits>& __a, + const istreambuf_iterator<_CharT, _Traits>& __b) + { return __a.equal(__b); } + + template + inline bool + operator!=(const istreambuf_iterator<_CharT, _Traits>& __a, + const istreambuf_iterator<_CharT, _Traits>& __b) + { return !__a.equal(__b); } + + + template + class ostreambuf_iterator + : public iterator + { + public: + + + + typedef _CharT char_type; + typedef _Traits traits_type; + typedef basic_streambuf<_CharT, _Traits> streambuf_type; + typedef basic_ostream<_CharT, _Traits> ostream_type; + + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + ostreambuf_iterator<_CharT2> >::__type + copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, + ostreambuf_iterator<_CharT2>); + + private: + streambuf_type* _M_sbuf; + bool _M_failed; + + public: + + ostreambuf_iterator(ostream_type& __s) noexcept + : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { } + + + ostreambuf_iterator(streambuf_type* __s) noexcept + : _M_sbuf(__s), _M_failed(!_M_sbuf) { } + + + ostreambuf_iterator& + operator=(_CharT __c) + { + if (!_M_failed && + _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof())) + _M_failed = true; + return *this; + } + + + ostreambuf_iterator& + operator*() + { return *this; } + + + ostreambuf_iterator& + operator++(int) + { return *this; } + + + ostreambuf_iterator& + operator++() + { return *this; } + + + bool + failed() const noexcept + { return _M_failed; } + + ostreambuf_iterator& + _M_put(const _CharT* __ws, streamsize __len) + { + if (__builtin_expect(!_M_failed, true) + && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len, + false)) + _M_failed = true; + return *this; + } + }; + + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT> >::__type + copy(istreambuf_iterator<_CharT> __first, + istreambuf_iterator<_CharT> __last, + ostreambuf_iterator<_CharT> __result) + { + if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed) + { + bool __ineof; + __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof); + if (!__ineof) + __result._M_failed = true; + } + return __result; + } + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT> >::__type + __copy_move_a2(_CharT* __first, _CharT* __last, + ostreambuf_iterator<_CharT> __result) + { + const streamsize __num = __last - __first; + if (__num > 0) + __result._M_put(__first, __num); + return __result; + } + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT> >::__type + __copy_move_a2(const _CharT* __first, const _CharT* __last, + ostreambuf_iterator<_CharT> __result) + { + const streamsize __num = __last - __first; + if (__num > 0) + __result._M_put(__first, __num); + return __result; + } + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + _CharT*>::__type + __copy_move_a2(istreambuf_iterator<_CharT> __first, + istreambuf_iterator<_CharT> __last, _CharT* __result) + { + typedef istreambuf_iterator<_CharT> __is_iterator_type; + typedef typename __is_iterator_type::traits_type traits_type; + typedef typename __is_iterator_type::streambuf_type streambuf_type; + typedef typename traits_type::int_type int_type; + + if (__first._M_sbuf && !__last._M_sbuf) + { + streambuf_type* __sb = __first._M_sbuf; + int_type __c = __sb->sgetc(); + while (!traits_type::eq_int_type(__c, traits_type::eof())) + { + const streamsize __n = __sb->egptr() - __sb->gptr(); + if (__n > 1) + { + traits_type::copy(__result, __sb->gptr(), __n); + __sb->__safe_gbump(__n); + __result += __n; + __c = __sb->underflow(); + } + else + { + *__result++ = traits_type::to_char_type(__c); + __c = __sb->snextc(); + } + } + } + return __result; + } + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + istreambuf_iterator<_CharT> >::__type + find(istreambuf_iterator<_CharT> __first, + istreambuf_iterator<_CharT> __last, const _CharT& __val) + { + typedef istreambuf_iterator<_CharT> __is_iterator_type; + typedef typename __is_iterator_type::traits_type traits_type; + typedef typename __is_iterator_type::streambuf_type streambuf_type; + typedef typename traits_type::int_type int_type; + + if (__first._M_sbuf && !__last._M_sbuf) + { + const int_type __ival = traits_type::to_int_type(__val); + streambuf_type* __sb = __first._M_sbuf; + int_type __c = __sb->sgetc(); + while (!traits_type::eq_int_type(__c, traits_type::eof()) + && !traits_type::eq_int_type(__c, __ival)) + { + streamsize __n = __sb->egptr() - __sb->gptr(); + if (__n > 1) + { + const _CharT* __p = traits_type::find(__sb->gptr(), + __n, __val); + if (__p) + __n = __p - __sb->gptr(); + __sb->__safe_gbump(__n); + __c = __sb->sgetc(); + } + else + __c = __sb->snextc(); + } + + if (!traits_type::eq_int_type(__c, traits_type::eof())) + __first._M_c = __c; + else + __first._M_sbuf = 0; + } + return __first; + } + + + + +} +# 49 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 71 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + template + void + __convert_to_v(const char*, _Tp&, ios_base::iostate&, + const __c_locale&) throw(); + + + template<> + void + __convert_to_v(const char*, float&, ios_base::iostate&, + const __c_locale&) throw(); + + template<> + void + __convert_to_v(const char*, double&, ios_base::iostate&, + const __c_locale&) throw(); + + template<> + void + __convert_to_v(const char*, long double&, ios_base::iostate&, + const __c_locale&) throw(); + + + + template + struct __pad + { + static void + _S_pad(ios_base& __io, _CharT __fill, _CharT* __news, + const _CharT* __olds, streamsize __newlen, streamsize __oldlen); + }; + + + + + + + template + _CharT* + __add_grouping(_CharT* __s, _CharT __sep, + const char* __gbeg, size_t __gsize, + const _CharT* __first, const _CharT* __last); + + + + + template + inline + ostreambuf_iterator<_CharT> + __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len) + { + __s._M_put(__ws, __len); + return __s; + } + + + template + inline + _OutIter + __write(_OutIter __s, const _CharT* __ws, int __len) + { + for (int __j = 0; __j < __len; __j++, ++__s) + *__s = __ws[__j]; + return __s; + } +# 149 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + template + class __ctype_abstract_base : public locale::facet, public ctype_base + { + public: + + + typedef _CharT char_type; +# 168 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + bool + is(mask __m, char_type __c) const + { return this->do_is(__m, __c); } +# 185 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + const char_type* + is(const char_type *__lo, const char_type *__hi, mask *__vec) const + { return this->do_is(__lo, __hi, __vec); } +# 201 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + const char_type* + scan_is(mask __m, const char_type* __lo, const char_type* __hi) const + { return this->do_scan_is(__m, __lo, __hi); } +# 217 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + const char_type* + scan_not(mask __m, const char_type* __lo, const char_type* __hi) const + { return this->do_scan_not(__m, __lo, __hi); } +# 231 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + char_type + toupper(char_type __c) const + { return this->do_toupper(__c); } +# 246 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + const char_type* + toupper(char_type *__lo, const char_type* __hi) const + { return this->do_toupper(__lo, __hi); } +# 260 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + char_type + tolower(char_type __c) const + { return this->do_tolower(__c); } +# 275 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + const char_type* + tolower(char_type* __lo, const char_type* __hi) const + { return this->do_tolower(__lo, __hi); } +# 292 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + char_type + widen(char __c) const + { return this->do_widen(__c); } +# 311 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + const char* + widen(const char* __lo, const char* __hi, char_type* __to) const + { return this->do_widen(__lo, __hi, __to); } +# 330 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + char + narrow(char_type __c, char __dfault) const + { return this->do_narrow(__c, __dfault); } +# 352 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + const char_type* + narrow(const char_type* __lo, const char_type* __hi, + char __dfault, char* __to) const + { return this->do_narrow(__lo, __hi, __dfault, __to); } + + protected: + explicit + __ctype_abstract_base(size_t __refs = 0): facet(__refs) { } + + virtual + ~__ctype_abstract_base() { } +# 377 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual bool + do_is(mask __m, char_type __c) const = 0; +# 396 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual const char_type* + do_is(const char_type* __lo, const char_type* __hi, + mask* __vec) const = 0; +# 415 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual const char_type* + do_scan_is(mask __m, const char_type* __lo, + const char_type* __hi) const = 0; +# 434 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual const char_type* + do_scan_not(mask __m, const char_type* __lo, + const char_type* __hi) const = 0; +# 452 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual char_type + do_toupper(char_type __c) const = 0; +# 469 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual const char_type* + do_toupper(char_type* __lo, const char_type* __hi) const = 0; +# 485 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual char_type + do_tolower(char_type __c) const = 0; +# 502 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual const char_type* + do_tolower(char_type* __lo, const char_type* __hi) const = 0; +# 521 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual char_type + do_widen(char __c) const = 0; +# 542 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual const char* + do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0; +# 563 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual char + do_narrow(char_type __c, char __dfault) const = 0; +# 588 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual const char_type* + do_narrow(const char_type* __lo, const char_type* __hi, + char __dfault, char* __to) const = 0; + }; +# 611 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + template + class ctype : public __ctype_abstract_base<_CharT> + { + public: + + typedef _CharT char_type; + typedef typename __ctype_abstract_base<_CharT>::mask mask; + + + static locale::id id; + + explicit + ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { } + + protected: + virtual + ~ctype(); + + virtual bool + do_is(mask __m, char_type __c) const; + + virtual const char_type* + do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const; + + virtual const char_type* + do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const; + + virtual const char_type* + do_scan_not(mask __m, const char_type* __lo, + const char_type* __hi) const; + + virtual char_type + do_toupper(char_type __c) const; + + virtual const char_type* + do_toupper(char_type* __lo, const char_type* __hi) const; + + virtual char_type + do_tolower(char_type __c) const; + + virtual const char_type* + do_tolower(char_type* __lo, const char_type* __hi) const; + + virtual char_type + do_widen(char __c) const; + + virtual const char* + do_widen(const char* __lo, const char* __hi, char_type* __dest) const; + + virtual char + do_narrow(char_type, char __dfault) const; + + virtual const char_type* + do_narrow(const char_type* __lo, const char_type* __hi, + char __dfault, char* __to) const; + }; + + template + locale::id ctype<_CharT>::id; +# 680 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + template<> + class ctype : public locale::facet, public ctype_base + { + public: + + + typedef char char_type; + + protected: + + __c_locale _M_c_locale_ctype; + bool _M_del; + __to_type _M_toupper; + __to_type _M_tolower; + const mask* _M_table; + mutable char _M_widen_ok; + mutable char _M_widen[1 + static_cast(-1)]; + mutable char _M_narrow[1 + static_cast(-1)]; + mutable char _M_narrow_ok; + + + public: + + static locale::id id; + + static const size_t table_size = 1 + static_cast(-1); +# 717 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + explicit + ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0); +# 730 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + explicit + ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false, + size_t __refs = 0); +# 743 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + inline bool + is(mask __m, char __c) const; +# 758 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + inline const char* + is(const char* __lo, const char* __hi, mask* __vec) const; +# 772 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + inline const char* + scan_is(mask __m, const char* __lo, const char* __hi) const; +# 786 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + inline const char* + scan_not(mask __m, const char* __lo, const char* __hi) const; +# 801 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + char_type + toupper(char_type __c) const + { return this->do_toupper(__c); } +# 818 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + const char_type* + toupper(char_type *__lo, const char_type* __hi) const + { return this->do_toupper(__lo, __hi); } +# 834 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + char_type + tolower(char_type __c) const + { return this->do_tolower(__c); } +# 851 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + const char_type* + tolower(char_type* __lo, const char_type* __hi) const + { return this->do_tolower(__lo, __hi); } +# 871 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + char_type + widen(char __c) const + { + if (_M_widen_ok) + return _M_widen[static_cast(__c)]; + this->_M_widen_init(); + return this->do_widen(__c); + } +# 898 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + const char* + widen(const char* __lo, const char* __hi, char_type* __to) const + { + if (_M_widen_ok == 1) + { + __builtin_memcpy(__to, __lo, __hi - __lo); + return __hi; + } + if (!_M_widen_ok) + _M_widen_init(); + return this->do_widen(__lo, __hi, __to); + } +# 929 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + char + narrow(char_type __c, char __dfault) const + { + if (_M_narrow[static_cast(__c)]) + return _M_narrow[static_cast(__c)]; + const char __t = do_narrow(__c, __dfault); + if (__t != __dfault) + _M_narrow[static_cast(__c)] = __t; + return __t; + } +# 962 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + const char_type* + narrow(const char_type* __lo, const char_type* __hi, + char __dfault, char* __to) const + { + if (__builtin_expect(_M_narrow_ok == 1, true)) + { + __builtin_memcpy(__to, __lo, __hi - __lo); + return __hi; + } + if (!_M_narrow_ok) + _M_narrow_init(); + return this->do_narrow(__lo, __hi, __dfault, __to); + } + + + + + + const mask* + table() const throw() + { return _M_table; } + + + static const mask* + classic_table() throw(); + protected: + + + + + + + + virtual + ~ctype(); +# 1011 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual char_type + do_toupper(char_type __c) const; +# 1028 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual const char_type* + do_toupper(char_type* __lo, const char_type* __hi) const; +# 1044 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual char_type + do_tolower(char_type __c) const; +# 1061 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual const char_type* + do_tolower(char_type* __lo, const char_type* __hi) const; +# 1081 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual char_type + do_widen(char __c) const + { return __c; } +# 1104 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual const char* + do_widen(const char* __lo, const char* __hi, char_type* __to) const + { + __builtin_memcpy(__to, __lo, __hi - __lo); + return __hi; + } +# 1130 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual char + do_narrow(char_type __c, char __dfault) const + { return __c; } +# 1156 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual const char_type* + do_narrow(const char_type* __lo, const char_type* __hi, + char __dfault, char* __to) const + { + __builtin_memcpy(__to, __lo, __hi - __lo); + return __hi; + } + + private: + void _M_narrow_init() const; + void _M_widen_init() const; + }; +# 1181 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + template<> + class ctype : public __ctype_abstract_base + { + public: + + + typedef wchar_t char_type; + typedef wctype_t __wmask_type; + + protected: + __c_locale _M_c_locale_ctype; + + + bool _M_narrow_ok; + char _M_narrow[128]; + wint_t _M_widen[1 + static_cast(-1)]; + + + mask _M_bit[16]; + __wmask_type _M_wmask[16]; + + public: + + + static locale::id id; +# 1214 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + explicit + ctype(size_t __refs = 0); +# 1225 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + explicit + ctype(__c_locale __cloc, size_t __refs = 0); + + protected: + __wmask_type + _M_convert_to_wmask(const mask __m) const throw(); + + + virtual + ~ctype(); +# 1249 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual bool + do_is(mask __m, char_type __c) const; +# 1268 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual const char_type* + do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const; +# 1286 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual const char_type* + do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const; +# 1304 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual const char_type* + do_scan_not(mask __m, const char_type* __lo, + const char_type* __hi) const; +# 1321 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual char_type + do_toupper(char_type __c) const; +# 1338 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual const char_type* + do_toupper(char_type* __lo, const char_type* __hi) const; +# 1354 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual char_type + do_tolower(char_type __c) const; +# 1371 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual const char_type* + do_tolower(char_type* __lo, const char_type* __hi) const; +# 1391 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual char_type + do_widen(char __c) const; +# 1413 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual const char* + do_widen(const char* __lo, const char* __hi, char_type* __to) const; +# 1436 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual char + do_narrow(char_type __c, char __dfault) const; +# 1462 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual const char_type* + do_narrow(const char_type* __lo, const char_type* __hi, + char __dfault, char* __to) const; + + + void + _M_initialize_ctype() throw(); + }; + + + + template + class ctype_byname : public ctype<_CharT> + { + public: + typedef typename ctype<_CharT>::mask mask; + + explicit + ctype_byname(const char* __s, size_t __refs = 0); + + + explicit + ctype_byname(const string& __s, size_t __refs = 0) + : ctype_byname(__s.c_str(), __refs) { } + + + protected: + virtual + ~ctype_byname() { }; + }; + + + template<> + class ctype_byname : public ctype + { + public: + explicit + ctype_byname(const char* __s, size_t __refs = 0); + + + explicit + ctype_byname(const string& __s, size_t __refs = 0); + + + protected: + virtual + ~ctype_byname(); + }; + + + template<> + class ctype_byname : public ctype + { + public: + explicit + ctype_byname(const char* __s, size_t __refs = 0); + + + explicit + ctype_byname(const string& __s, size_t __refs = 0); + + + protected: + virtual + ~ctype_byname(); + }; + + + +} + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/ctype_inline.h" 1 3 +# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/ctype_inline.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + bool + ctype:: + is(mask __m, char __c) const + { return _M_table[static_cast(__c)] & __m; } + + const char* + ctype:: + is(const char* __low, const char* __high, mask* __vec) const + { + while (__low < __high) + *__vec++ = _M_table[static_cast(*__low++)]; + return __high; + } + + const char* + ctype:: + scan_is(mask __m, const char* __low, const char* __high) const + { + while (__low < __high + && !(_M_table[static_cast(*__low)] & __m)) + ++__low; + return __low; + } + + const char* + ctype:: + scan_not(mask __m, const char* __low, const char* __high) const + { + while (__low < __high + && (_M_table[static_cast(*__low)] & __m) != 0) + ++__low; + return __low; + } + + +} +# 1535 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + class __num_base + { + public: + + + enum + { + _S_ominus, + _S_oplus, + _S_ox, + _S_oX, + _S_odigits, + _S_odigits_end = _S_odigits + 16, + _S_oudigits = _S_odigits_end, + _S_oudigits_end = _S_oudigits + 16, + _S_oe = _S_odigits + 14, + _S_oE = _S_oudigits + 14, + _S_oend = _S_oudigits_end + }; + + + + + + + static const char* _S_atoms_out; + + + + static const char* _S_atoms_in; + + enum + { + _S_iminus, + _S_iplus, + _S_ix, + _S_iX, + _S_izero, + _S_ie = _S_izero + 14, + _S_iE = _S_izero + 20, + _S_iend = 26 + }; + + + + static void + _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw(); + }; + + template + struct __numpunct_cache : public locale::facet + { + const char* _M_grouping; + size_t _M_grouping_size; + bool _M_use_grouping; + const _CharT* _M_truename; + size_t _M_truename_size; + const _CharT* _M_falsename; + size_t _M_falsename_size; + _CharT _M_decimal_point; + _CharT _M_thousands_sep; + + + + + + _CharT _M_atoms_out[__num_base::_S_oend]; + + + + + + _CharT _M_atoms_in[__num_base::_S_iend]; + + bool _M_allocated; + + __numpunct_cache(size_t __refs = 0) + : facet(__refs), _M_grouping(0), _M_grouping_size(0), + _M_use_grouping(false), + _M_truename(0), _M_truename_size(0), _M_falsename(0), + _M_falsename_size(0), _M_decimal_point(_CharT()), + _M_thousands_sep(_CharT()), _M_allocated(false) + { } + + ~__numpunct_cache(); + + void + _M_cache(const locale& __loc); + + private: + __numpunct_cache& + operator=(const __numpunct_cache&); + + explicit + __numpunct_cache(const __numpunct_cache&); + }; + + template + __numpunct_cache<_CharT>::~__numpunct_cache() + { + if (_M_allocated) + { + delete [] _M_grouping; + delete [] _M_truename; + delete [] _M_falsename; + } + } + +namespace __cxx11 { +# 1665 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + template + class numpunct : public locale::facet + { + public: + + + + typedef _CharT char_type; + typedef basic_string<_CharT> string_type; + + typedef __numpunct_cache<_CharT> __cache_type; + + protected: + __cache_type* _M_data; + + public: + + static locale::id id; + + + + + + + explicit + numpunct(size_t __refs = 0) + : facet(__refs), _M_data(0) + { _M_initialize_numpunct(); } +# 1703 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + explicit + numpunct(__cache_type* __cache, size_t __refs = 0) + : facet(__refs), _M_data(__cache) + { _M_initialize_numpunct(); } +# 1717 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + explicit + numpunct(__c_locale __cloc, size_t __refs = 0) + : facet(__refs), _M_data(0) + { _M_initialize_numpunct(__cloc); } +# 1731 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + char_type + decimal_point() const + { return this->do_decimal_point(); } +# 1744 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + char_type + thousands_sep() const + { return this->do_thousands_sep(); } +# 1775 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + string + grouping() const + { return this->do_grouping(); } +# 1788 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + string_type + truename() const + { return this->do_truename(); } +# 1801 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + string_type + falsename() const + { return this->do_falsename(); } + + protected: + + virtual + ~numpunct(); +# 1818 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual char_type + do_decimal_point() const + { return _M_data->_M_decimal_point; } +# 1830 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual char_type + do_thousands_sep() const + { return _M_data->_M_thousands_sep; } +# 1843 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual string + do_grouping() const + { return _M_data->_M_grouping; } +# 1856 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual string_type + do_truename() const + { return _M_data->_M_truename; } +# 1869 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual string_type + do_falsename() const + { return _M_data->_M_falsename; } + + + void + _M_initialize_numpunct(__c_locale __cloc = 0); + }; + + template + locale::id numpunct<_CharT>::id; + + template<> + numpunct::~numpunct(); + + template<> + void + numpunct::_M_initialize_numpunct(__c_locale __cloc); + + + template<> + numpunct::~numpunct(); + + template<> + void + numpunct::_M_initialize_numpunct(__c_locale __cloc); + + + + template + class numpunct_byname : public numpunct<_CharT> + { + public: + typedef _CharT char_type; + typedef basic_string<_CharT> string_type; + + explicit + numpunct_byname(const char* __s, size_t __refs = 0) + : numpunct<_CharT>(__refs) + { + if (__builtin_strcmp(__s, "C") != 0 + && __builtin_strcmp(__s, "POSIX") != 0) + { + __c_locale __tmp; + this->_S_create_c_locale(__tmp, __s); + this->_M_initialize_numpunct(__tmp); + this->_S_destroy_c_locale(__tmp); + } + } + + + explicit + numpunct_byname(const string& __s, size_t __refs = 0) + : numpunct_byname(__s.c_str(), __refs) { } + + + protected: + virtual + ~numpunct_byname() { } + }; + +} +# 1947 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + template + class num_get : public locale::facet + { + public: + + + + typedef _CharT char_type; + typedef _InIter iter_type; + + + + static locale::id id; +# 1968 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + explicit + num_get(size_t __refs = 0) : facet(__refs) { } +# 1994 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, bool& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } +# 2031 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, long& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned short& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned int& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned long& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, long long& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned long long& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } +# 2091 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, float& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, double& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, long double& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } +# 2134 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, void*& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + protected: + + virtual ~num_get() { } + + __attribute ((__abi_tag__ ("cxx11"))) + iter_type + _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&, + string&) const; + + template + __attribute ((__abi_tag__ ("cxx11"))) + iter_type + _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&, + _ValueT&) const; + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type + _M_find(const _CharT2*, size_t __len, _CharT2 __c) const + { + int __ret = -1; + if (__len <= 10) + { + if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len)) + __ret = __c - _CharT2('0'); + } + else + { + if (__c >= _CharT2('0') && __c <= _CharT2('9')) + __ret = __c - _CharT2('0'); + else if (__c >= _CharT2('a') && __c <= _CharT2('f')) + __ret = 10 + (__c - _CharT2('a')); + else if (__c >= _CharT2('A') && __c <= _CharT2('F')) + __ret = 10 + (__c - _CharT2('A')); + } + return __ret; + } + + template + typename __gnu_cxx::__enable_if::__value, + int>::__type + _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const + { + int __ret = -1; + const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c); + if (__q) + { + __ret = __q - __zero; + if (__ret > 15) + __ret -= 6; + } + return __ret; + } +# 2207 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const; + + virtual iter_type + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, long& __v) const + { return _M_extract_int(__beg, __end, __io, __err, __v); } + + virtual iter_type + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned short& __v) const + { return _M_extract_int(__beg, __end, __io, __err, __v); } + + virtual iter_type + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned int& __v) const + { return _M_extract_int(__beg, __end, __io, __err, __v); } + + virtual iter_type + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned long& __v) const + { return _M_extract_int(__beg, __end, __io, __err, __v); } + + + virtual iter_type + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, long long& __v) const + { return _M_extract_int(__beg, __end, __io, __err, __v); } + + virtual iter_type + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned long long& __v) const + { return _M_extract_int(__beg, __end, __io, __err, __v); } + + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const; + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + double&) const; + + + + + + + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + long double&) const; + + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const; +# 2270 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + }; + + template + locale::id num_get<_CharT, _InIter>::id; +# 2288 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + template + class num_put : public locale::facet + { + public: + + + + typedef _CharT char_type; + typedef _OutIter iter_type; + + + + static locale::id id; +# 2309 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + explicit + num_put(size_t __refs = 0) : facet(__refs) { } +# 2327 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const + { return this->do_put(__s, __io, __fill, __v); } +# 2369 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, long __v) const + { return this->do_put(__s, __io, __fill, __v); } + + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, + unsigned long __v) const + { return this->do_put(__s, __io, __fill, __v); } + + + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const + { return this->do_put(__s, __io, __fill, __v); } + + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, + unsigned long long __v) const + { return this->do_put(__s, __io, __fill, __v); } +# 2432 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, double __v) const + { return this->do_put(__s, __io, __fill, __v); } + + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, + long double __v) const + { return this->do_put(__s, __io, __fill, __v); } +# 2457 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, + const void* __v) const + { return this->do_put(__s, __io, __fill, __v); } + + protected: + template + iter_type + _M_insert_float(iter_type, ios_base& __io, char_type __fill, + char __mod, _ValueT __v) const; + + void + _M_group_float(const char* __grouping, size_t __grouping_size, + char_type __sep, const char_type* __p, char_type* __new, + char_type* __cs, int& __len) const; + + template + iter_type + _M_insert_int(iter_type, ios_base& __io, char_type __fill, + _ValueT __v) const; + + void + _M_group_int(const char* __grouping, size_t __grouping_size, + char_type __sep, ios_base& __io, char_type* __new, + char_type* __cs, int& __len) const; + + void + _M_pad(char_type __fill, streamsize __w, ios_base& __io, + char_type* __new, const char_type* __cs, int& __len) const; + + + virtual + ~num_put() { }; +# 2505 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + virtual iter_type + do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const; + + virtual iter_type + do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const + { return _M_insert_int(__s, __io, __fill, __v); } + + virtual iter_type + do_put(iter_type __s, ios_base& __io, char_type __fill, + unsigned long __v) const + { return _M_insert_int(__s, __io, __fill, __v); } + + + virtual iter_type + do_put(iter_type __s, ios_base& __io, char_type __fill, + long long __v) const + { return _M_insert_int(__s, __io, __fill, __v); } + + virtual iter_type + do_put(iter_type __s, ios_base& __io, char_type __fill, + unsigned long long __v) const + { return _M_insert_int(__s, __io, __fill, __v); } + + + virtual iter_type + do_put(iter_type, ios_base&, char_type, double) const; + + + + + + + virtual iter_type + do_put(iter_type, ios_base&, char_type, long double) const; + + + virtual iter_type + do_put(iter_type, ios_base&, char_type, const void*) const; + + + + + + + + }; + + template + locale::id num_put<_CharT, _OutIter>::id; +# 2563 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3 + template + inline bool + isspace(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::space, __c); } + + + template + inline bool + isprint(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::print, __c); } + + + template + inline bool + iscntrl(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::cntrl, __c); } + + + template + inline bool + isupper(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::upper, __c); } + + + template + inline bool + islower(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::lower, __c); } + + + template + inline bool + isalpha(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::alpha, __c); } + + + template + inline bool + isdigit(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::digit, __c); } + + + template + inline bool + ispunct(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::punct, __c); } + + + template + inline bool + isxdigit(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::xdigit, __c); } + + + template + inline bool + isalnum(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::alnum, __c); } + + + template + inline bool + isgraph(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::graph, __c); } + + + + template + inline bool + isblank(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::blank, __c); } + + + + template + inline _CharT + toupper(_CharT __c, const locale& __loc) + { return use_facet >(__loc).toupper(__c); } + + + template + inline _CharT + tolower(_CharT __c, const locale& __loc) + { return use_facet >(__loc).tolower(__c); } + + +} + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 1 3 +# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template + struct __use_cache + { + const _Facet* + operator() (const locale& __loc) const; + }; + + + template + struct __use_cache<__numpunct_cache<_CharT> > + { + const __numpunct_cache<_CharT>* + operator() (const locale& __loc) const + { + const size_t __i = numpunct<_CharT>::id._M_id(); + const locale::facet** __caches = __loc._M_impl->_M_caches; + if (!__caches[__i]) + { + __numpunct_cache<_CharT>* __tmp = 0; + try + { + __tmp = new __numpunct_cache<_CharT>; + __tmp->_M_cache(__loc); + } + catch(...) + { + delete __tmp; + throw; + } + __loc._M_impl->_M_install_cache(__tmp, __i); + } + return static_cast*>(__caches[__i]); + } + }; + + template + void + __numpunct_cache<_CharT>::_M_cache(const locale& __loc) + { + const numpunct<_CharT>& __np = use_facet >(__loc); + + char* __grouping = 0; + _CharT* __truename = 0; + _CharT* __falsename = 0; + try + { + const string& __g = __np.grouping(); + _M_grouping_size = __g.size(); + __grouping = new char[_M_grouping_size]; + __g.copy(__grouping, _M_grouping_size); + _M_use_grouping = (_M_grouping_size + && static_cast(__grouping[0]) > 0 + && (__grouping[0] + != __gnu_cxx::__numeric_traits::__max)); + + const basic_string<_CharT>& __tn = __np.truename(); + _M_truename_size = __tn.size(); + __truename = new _CharT[_M_truename_size]; + __tn.copy(__truename, _M_truename_size); + + const basic_string<_CharT>& __fn = __np.falsename(); + _M_falsename_size = __fn.size(); + __falsename = new _CharT[_M_falsename_size]; + __fn.copy(__falsename, _M_falsename_size); + + _M_decimal_point = __np.decimal_point(); + _M_thousands_sep = __np.thousands_sep(); + + const ctype<_CharT>& __ct = use_facet >(__loc); + __ct.widen(__num_base::_S_atoms_out, + __num_base::_S_atoms_out + + __num_base::_S_oend, _M_atoms_out); + __ct.widen(__num_base::_S_atoms_in, + __num_base::_S_atoms_in + + __num_base::_S_iend, _M_atoms_in); + + _M_grouping = __grouping; + _M_truename = __truename; + _M_falsename = __falsename; + _M_allocated = true; + } + catch(...) + { + delete [] __grouping; + delete [] __truename; + delete [] __falsename; + throw; + } + } +# 139 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3 + __attribute__ ((__pure__)) bool + __verify_grouping(const char* __grouping, size_t __grouping_size, + const string& __grouping_tmp) throw (); + + + + template + __attribute ((__abi_tag__ ("cxx11"))) + _InIter + num_get<_CharT, _InIter>:: + _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io, + ios_base::iostate& __err, string& __xtrc) const + { + typedef char_traits<_CharT> __traits_type; + typedef __numpunct_cache<_CharT> __cache_type; + __use_cache<__cache_type> __uc; + const locale& __loc = __io._M_getloc(); + const __cache_type* __lc = __uc(__loc); + const _CharT* __lit = __lc->_M_atoms_in; + char_type __c = char_type(); + + + bool __testeof = __beg == __end; + + + if (!__testeof) + { + __c = *__beg; + const bool __plus = __c == __lit[__num_base::_S_iplus]; + if ((__plus || __c == __lit[__num_base::_S_iminus]) + && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) + && !(__c == __lc->_M_decimal_point)) + { + __xtrc += __plus ? '+' : '-'; + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + } + + + bool __found_mantissa = false; + int __sep_pos = 0; + while (!__testeof) + { + if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) + || __c == __lc->_M_decimal_point) + break; + else if (__c == __lit[__num_base::_S_izero]) + { + if (!__found_mantissa) + { + __xtrc += '0'; + __found_mantissa = true; + } + ++__sep_pos; + + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + else + break; + } + + + bool __found_dec = false; + bool __found_sci = false; + string __found_grouping; + if (__lc->_M_use_grouping) + __found_grouping.reserve(32); + const char_type* __lit_zero = __lit + __num_base::_S_izero; + + if (!__lc->_M_allocated) + + while (!__testeof) + { + const int __digit = _M_find(__lit_zero, 10, __c); + if (__digit != -1) + { + __xtrc += '0' + __digit; + __found_mantissa = true; + } + else if (__c == __lc->_M_decimal_point + && !__found_dec && !__found_sci) + { + __xtrc += '.'; + __found_dec = true; + } + else if ((__c == __lit[__num_base::_S_ie] + || __c == __lit[__num_base::_S_iE]) + && !__found_sci && __found_mantissa) + { + + __xtrc += 'e'; + __found_sci = true; + + + if (++__beg != __end) + { + __c = *__beg; + const bool __plus = __c == __lit[__num_base::_S_iplus]; + if (__plus || __c == __lit[__num_base::_S_iminus]) + __xtrc += __plus ? '+' : '-'; + else + continue; + } + else + { + __testeof = true; + break; + } + } + else + break; + + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + else + while (!__testeof) + { + + + if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) + { + if (!__found_dec && !__found_sci) + { + + + if (__sep_pos) + { + __found_grouping += static_cast(__sep_pos); + __sep_pos = 0; + } + else + { + + + __xtrc.clear(); + break; + } + } + else + break; + } + else if (__c == __lc->_M_decimal_point) + { + if (!__found_dec && !__found_sci) + { + + + + if (__found_grouping.size()) + __found_grouping += static_cast(__sep_pos); + __xtrc += '.'; + __found_dec = true; + } + else + break; + } + else + { + const char_type* __q = + __traits_type::find(__lit_zero, 10, __c); + if (__q) + { + __xtrc += '0' + (__q - __lit_zero); + __found_mantissa = true; + ++__sep_pos; + } + else if ((__c == __lit[__num_base::_S_ie] + || __c == __lit[__num_base::_S_iE]) + && !__found_sci && __found_mantissa) + { + + if (__found_grouping.size() && !__found_dec) + __found_grouping += static_cast(__sep_pos); + __xtrc += 'e'; + __found_sci = true; + + + if (++__beg != __end) + { + __c = *__beg; + const bool __plus = __c == __lit[__num_base::_S_iplus]; + if ((__plus || __c == __lit[__num_base::_S_iminus]) + && !(__lc->_M_use_grouping + && __c == __lc->_M_thousands_sep) + && !(__c == __lc->_M_decimal_point)) + __xtrc += __plus ? '+' : '-'; + else + continue; + } + else + { + __testeof = true; + break; + } + } + else + break; + } + + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + + + + if (__found_grouping.size()) + { + + if (!__found_dec && !__found_sci) + __found_grouping += static_cast(__sep_pos); + + if (!std::__verify_grouping(__lc->_M_grouping, + __lc->_M_grouping_size, + __found_grouping)) + __err = ios_base::failbit; + } + + return __beg; + } + + template + template + __attribute ((__abi_tag__ ("cxx11"))) + _InIter + num_get<_CharT, _InIter>:: + _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io, + ios_base::iostate& __err, _ValueT& __v) const + { + typedef char_traits<_CharT> __traits_type; + using __gnu_cxx::__add_unsigned; + typedef typename __add_unsigned<_ValueT>::__type __unsigned_type; + typedef __numpunct_cache<_CharT> __cache_type; + __use_cache<__cache_type> __uc; + const locale& __loc = __io._M_getloc(); + const __cache_type* __lc = __uc(__loc); + const _CharT* __lit = __lc->_M_atoms_in; + char_type __c = char_type(); + + + const ios_base::fmtflags __basefield = __io.flags() + & ios_base::basefield; + const bool __oct = __basefield == ios_base::oct; + int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10); + + + bool __testeof = __beg == __end; + + + bool __negative = false; + if (!__testeof) + { + __c = *__beg; + __negative = __c == __lit[__num_base::_S_iminus]; + if ((__negative || __c == __lit[__num_base::_S_iplus]) + && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) + && !(__c == __lc->_M_decimal_point)) + { + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + } + + + + bool __found_zero = false; + int __sep_pos = 0; + while (!__testeof) + { + if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) + || __c == __lc->_M_decimal_point) + break; + else if (__c == __lit[__num_base::_S_izero] + && (!__found_zero || __base == 10)) + { + __found_zero = true; + ++__sep_pos; + if (__basefield == 0) + __base = 8; + if (__base == 8) + __sep_pos = 0; + } + else if (__found_zero + && (__c == __lit[__num_base::_S_ix] + || __c == __lit[__num_base::_S_iX])) + { + if (__basefield == 0) + __base = 16; + if (__base == 16) + { + __found_zero = false; + __sep_pos = 0; + } + else + break; + } + else + break; + + if (++__beg != __end) + { + __c = *__beg; + if (!__found_zero) + break; + } + else + __testeof = true; + } + + + + const size_t __len = (__base == 16 ? __num_base::_S_iend + - __num_base::_S_izero : __base); + + + string __found_grouping; + if (__lc->_M_use_grouping) + __found_grouping.reserve(32); + bool __testfail = false; + bool __testoverflow = false; + const __unsigned_type __max = + (__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed) + ? -__gnu_cxx::__numeric_traits<_ValueT>::__min + : __gnu_cxx::__numeric_traits<_ValueT>::__max; + const __unsigned_type __smax = __max / __base; + __unsigned_type __result = 0; + int __digit = 0; + const char_type* __lit_zero = __lit + __num_base::_S_izero; + + if (!__lc->_M_allocated) + + while (!__testeof) + { + __digit = _M_find(__lit_zero, __len, __c); + if (__digit == -1) + break; + + if (__result > __smax) + __testoverflow = true; + else + { + __result *= __base; + __testoverflow |= __result > __max - __digit; + __result += __digit; + ++__sep_pos; + } + + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + else + while (!__testeof) + { + + + if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) + { + + + if (__sep_pos) + { + __found_grouping += static_cast(__sep_pos); + __sep_pos = 0; + } + else + { + __testfail = true; + break; + } + } + else if (__c == __lc->_M_decimal_point) + break; + else + { + const char_type* __q = + __traits_type::find(__lit_zero, __len, __c); + if (!__q) + break; + + __digit = __q - __lit_zero; + if (__digit > 15) + __digit -= 6; + if (__result > __smax) + __testoverflow = true; + else + { + __result *= __base; + __testoverflow |= __result > __max - __digit; + __result += __digit; + ++__sep_pos; + } + } + + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + + + + if (__found_grouping.size()) + { + + __found_grouping += static_cast(__sep_pos); + + if (!std::__verify_grouping(__lc->_M_grouping, + __lc->_M_grouping_size, + __found_grouping)) + __err = ios_base::failbit; + } + + + + if ((!__sep_pos && !__found_zero && !__found_grouping.size()) + || __testfail) + { + __v = 0; + __err = ios_base::failbit; + } + else if (__testoverflow) + { + if (__negative + && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed) + __v = __gnu_cxx::__numeric_traits<_ValueT>::__min; + else + __v = __gnu_cxx::__numeric_traits<_ValueT>::__max; + __err = ios_base::failbit; + } + else + __v = __negative ? -__result : __result; + + if (__testeof) + __err |= ios_base::eofbit; + return __beg; + } + + + + template + _InIter + num_get<_CharT, _InIter>:: + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, bool& __v) const + { + if (!(__io.flags() & ios_base::boolalpha)) + { + + + + long __l = -1; + __beg = _M_extract_int(__beg, __end, __io, __err, __l); + if (__l == 0 || __l == 1) + __v = bool(__l); + else + { + + + __v = true; + __err = ios_base::failbit; + if (__beg == __end) + __err |= ios_base::eofbit; + } + } + else + { + + typedef __numpunct_cache<_CharT> __cache_type; + __use_cache<__cache_type> __uc; + const locale& __loc = __io._M_getloc(); + const __cache_type* __lc = __uc(__loc); + + bool __testf = true; + bool __testt = true; + bool __donef = __lc->_M_falsename_size == 0; + bool __donet = __lc->_M_truename_size == 0; + bool __testeof = false; + size_t __n = 0; + while (!__donef || !__donet) + { + if (__beg == __end) + { + __testeof = true; + break; + } + + const char_type __c = *__beg; + + if (!__donef) + __testf = __c == __lc->_M_falsename[__n]; + + if (!__testf && __donet) + break; + + if (!__donet) + __testt = __c == __lc->_M_truename[__n]; + + if (!__testt && __donef) + break; + + if (!__testt && !__testf) + break; + + ++__n; + ++__beg; + + __donef = !__testf || __n >= __lc->_M_falsename_size; + __donet = !__testt || __n >= __lc->_M_truename_size; + } + if (__testf && __n == __lc->_M_falsename_size && __n) + { + __v = false; + if (__testt && __n == __lc->_M_truename_size) + __err = ios_base::failbit; + else + __err = __testeof ? ios_base::eofbit : ios_base::goodbit; + } + else if (__testt && __n == __lc->_M_truename_size && __n) + { + __v = true; + __err = __testeof ? ios_base::eofbit : ios_base::goodbit; + } + else + { + + + __v = false; + __err = ios_base::failbit; + if (__testeof) + __err |= ios_base::eofbit; + } + } + return __beg; + } + + template + _InIter + num_get<_CharT, _InIter>:: + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, float& __v) const + { + string __xtrc; + __xtrc.reserve(32); + __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); + std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); + if (__beg == __end) + __err |= ios_base::eofbit; + return __beg; + } + + template + _InIter + num_get<_CharT, _InIter>:: + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, double& __v) const + { + string __xtrc; + __xtrc.reserve(32); + __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); + std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); + if (__beg == __end) + __err |= ios_base::eofbit; + return __beg; + } +# 735 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3 + template + _InIter + num_get<_CharT, _InIter>:: + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, long double& __v) const + { + string __xtrc; + __xtrc.reserve(32); + __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); + std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); + if (__beg == __end) + __err |= ios_base::eofbit; + return __beg; + } + + template + _InIter + num_get<_CharT, _InIter>:: + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, void*& __v) const + { + + typedef ios_base::fmtflags fmtflags; + const fmtflags __fmt = __io.flags(); + __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex); + + typedef __gnu_cxx::__conditional_type<(sizeof(void*) + <= sizeof(unsigned long)), + unsigned long, unsigned long long>::__type _UIntPtrType; + + _UIntPtrType __ul; + __beg = _M_extract_int(__beg, __end, __io, __err, __ul); + + + __io.flags(__fmt); + + __v = reinterpret_cast(__ul); + return __beg; + } + + + + template + void + num_put<_CharT, _OutIter>:: + _M_pad(_CharT __fill, streamsize __w, ios_base& __io, + _CharT* __new, const _CharT* __cs, int& __len) const + { + + + __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new, + __cs, __w, __len); + __len = static_cast(__w); + } + + + + template + int + __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit, + ios_base::fmtflags __flags, bool __dec) + { + _CharT* __buf = __bufend; + if (__builtin_expect(__dec, true)) + { + + do + { + *--__buf = __lit[(__v % 10) + __num_base::_S_odigits]; + __v /= 10; + } + while (__v != 0); + } + else if ((__flags & ios_base::basefield) == ios_base::oct) + { + + do + { + *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits]; + __v >>= 3; + } + while (__v != 0); + } + else + { + + const bool __uppercase = __flags & ios_base::uppercase; + const int __case_offset = __uppercase ? __num_base::_S_oudigits + : __num_base::_S_odigits; + do + { + *--__buf = __lit[(__v & 0xf) + __case_offset]; + __v >>= 4; + } + while (__v != 0); + } + return __bufend - __buf; + } + + + + template + void + num_put<_CharT, _OutIter>:: + _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep, + ios_base&, _CharT* __new, _CharT* __cs, int& __len) const + { + _CharT* __p = std::__add_grouping(__new, __sep, __grouping, + __grouping_size, __cs, __cs + __len); + __len = __p - __new; + } + + template + template + _OutIter + num_put<_CharT, _OutIter>:: + _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill, + _ValueT __v) const + { + using __gnu_cxx::__add_unsigned; + typedef typename __add_unsigned<_ValueT>::__type __unsigned_type; + typedef __numpunct_cache<_CharT> __cache_type; + __use_cache<__cache_type> __uc; + const locale& __loc = __io._M_getloc(); + const __cache_type* __lc = __uc(__loc); + const _CharT* __lit = __lc->_M_atoms_out; + const ios_base::fmtflags __flags = __io.flags(); + + + const int __ilen = 5 * sizeof(_ValueT); + _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __ilen)); + + + + const ios_base::fmtflags __basefield = __flags & ios_base::basefield; + const bool __dec = (__basefield != ios_base::oct + && __basefield != ios_base::hex); + const __unsigned_type __u = ((__v > 0 || !__dec) + ? __unsigned_type(__v) + : -__unsigned_type(__v)); + int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec); + __cs += __ilen - __len; + + + if (__lc->_M_use_grouping) + { + + + _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * (__len + 1) + * 2)); + _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size, + __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len); + __cs = __cs2 + 2; + } + + + if (__builtin_expect(__dec, true)) + { + + if (__v >= 0) + { + if (bool(__flags & ios_base::showpos) + && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed) + *--__cs = __lit[__num_base::_S_oplus], ++__len; + } + else + *--__cs = __lit[__num_base::_S_ominus], ++__len; + } + else if (bool(__flags & ios_base::showbase) && __v) + { + if (__basefield == ios_base::oct) + *--__cs = __lit[__num_base::_S_odigits], ++__len; + else + { + + const bool __uppercase = __flags & ios_base::uppercase; + *--__cs = __lit[__num_base::_S_ox + __uppercase]; + + *--__cs = __lit[__num_base::_S_odigits]; + __len += 2; + } + } + + + const streamsize __w = __io.width(); + if (__w > static_cast(__len)) + { + _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __w)); + _M_pad(__fill, __w, __io, __cs3, __cs, __len); + __cs = __cs3; + } + __io.width(0); + + + + return std::__write(__s, __cs, __len); + } + + template + void + num_put<_CharT, _OutIter>:: + _M_group_float(const char* __grouping, size_t __grouping_size, + _CharT __sep, const _CharT* __p, _CharT* __new, + _CharT* __cs, int& __len) const + { + + + + const int __declen = __p ? __p - __cs : __len; + _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping, + __grouping_size, + __cs, __cs + __declen); + + + int __newlen = __p2 - __new; + if (__p) + { + char_traits<_CharT>::copy(__p2, __p, __len - __declen); + __newlen += __len - __declen; + } + __len = __newlen; + } +# 971 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3 + template + template + _OutIter + num_put<_CharT, _OutIter>:: + _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod, + _ValueT __v) const + { + typedef __numpunct_cache<_CharT> __cache_type; + __use_cache<__cache_type> __uc; + const locale& __loc = __io._M_getloc(); + const __cache_type* __lc = __uc(__loc); + + + const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision(); + + const int __max_digits = + __gnu_cxx::__numeric_traits<_ValueT>::__digits10; + + + int __len; + + char __fbuf[16]; + __num_base::_S_format_float(__io, __fbuf, __mod); + + + + const bool __use_prec = + (__io.flags() & ios_base::floatfield) != ios_base::floatfield; + + + + int __cs_size = __max_digits * 3; + char* __cs = static_cast(__builtin_alloca(__cs_size)); + if (__use_prec) + __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, + __fbuf, __prec, __v); + else + __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, + __fbuf, __v); + + + if (__len >= __cs_size) + { + __cs_size = __len + 1; + __cs = static_cast(__builtin_alloca(__cs_size)); + if (__use_prec) + __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, + __fbuf, __prec, __v); + else + __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, + __fbuf, __v); + } +# 1044 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3 + const ctype<_CharT>& __ctype = use_facet >(__loc); + + _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __len)); + __ctype.widen(__cs, __cs + __len, __ws); + + + _CharT* __wp = 0; + const char* __p = char_traits::find(__cs, __len, '.'); + if (__p) + { + __wp = __ws + (__p - __cs); + *__wp = __lc->_M_decimal_point; + } + + + + + if (__lc->_M_use_grouping + && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9' + && __cs[1] >= '0' && __cs[2] >= '0'))) + { + + + _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __len * 2)); + + streamsize __off = 0; + if (__cs[0] == '-' || __cs[0] == '+') + { + __off = 1; + __ws2[0] = __ws[0]; + __len -= 1; + } + + _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size, + __lc->_M_thousands_sep, __wp, __ws2 + __off, + __ws + __off, __len); + __len += __off; + + __ws = __ws2; + } + + + const streamsize __w = __io.width(); + if (__w > static_cast(__len)) + { + _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __w)); + _M_pad(__fill, __w, __io, __ws3, __ws, __len); + __ws = __ws3; + } + __io.width(0); + + + + return std::__write(__s, __ws, __len); + } + + template + _OutIter + num_put<_CharT, _OutIter>:: + do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const + { + const ios_base::fmtflags __flags = __io.flags(); + if ((__flags & ios_base::boolalpha) == 0) + { + const long __l = __v; + __s = _M_insert_int(__s, __io, __fill, __l); + } + else + { + typedef __numpunct_cache<_CharT> __cache_type; + __use_cache<__cache_type> __uc; + const locale& __loc = __io._M_getloc(); + const __cache_type* __lc = __uc(__loc); + + const _CharT* __name = __v ? __lc->_M_truename + : __lc->_M_falsename; + int __len = __v ? __lc->_M_truename_size + : __lc->_M_falsename_size; + + const streamsize __w = __io.width(); + if (__w > static_cast(__len)) + { + const streamsize __plen = __w - __len; + _CharT* __ps + = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __plen)); + + char_traits<_CharT>::assign(__ps, __plen, __fill); + __io.width(0); + + if ((__flags & ios_base::adjustfield) == ios_base::left) + { + __s = std::__write(__s, __name, __len); + __s = std::__write(__s, __ps, __plen); + } + else + { + __s = std::__write(__s, __ps, __plen); + __s = std::__write(__s, __name, __len); + } + return __s; + } + __io.width(0); + __s = std::__write(__s, __name, __len); + } + return __s; + } + + template + _OutIter + num_put<_CharT, _OutIter>:: + do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const + { return _M_insert_float(__s, __io, __fill, char(), __v); } +# 1169 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3 + template + _OutIter + num_put<_CharT, _OutIter>:: + do_put(iter_type __s, ios_base& __io, char_type __fill, + long double __v) const + { return _M_insert_float(__s, __io, __fill, 'L', __v); } + + template + _OutIter + num_put<_CharT, _OutIter>:: + do_put(iter_type __s, ios_base& __io, char_type __fill, + const void* __v) const + { + const ios_base::fmtflags __flags = __io.flags(); + const ios_base::fmtflags __fmt = ~(ios_base::basefield + | ios_base::uppercase); + __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase)); + + typedef __gnu_cxx::__conditional_type<(sizeof(const void*) + <= sizeof(unsigned long)), + unsigned long, unsigned long long>::__type _UIntPtrType; + + __s = _M_insert_int(__s, __io, __fill, + reinterpret_cast<_UIntPtrType>(__v)); + __io.flags(__flags); + return __s; + } +# 1206 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3 + template + void + __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill, + _CharT* __news, const _CharT* __olds, + streamsize __newlen, streamsize __oldlen) + { + const size_t __plen = static_cast(__newlen - __oldlen); + const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield; + + + if (__adjust == ios_base::left) + { + _Traits::copy(__news, __olds, __oldlen); + _Traits::assign(__news + __oldlen, __plen, __fill); + return; + } + + size_t __mod = 0; + if (__adjust == ios_base::internal) + { + + + + const locale& __loc = __io._M_getloc(); + const ctype<_CharT>& __ctype = use_facet >(__loc); + + if (__ctype.widen('-') == __olds[0] + || __ctype.widen('+') == __olds[0]) + { + __news[0] = __olds[0]; + __mod = 1; + ++__news; + } + else if (__ctype.widen('0') == __olds[0] + && __oldlen > 1 + && (__ctype.widen('x') == __olds[1] + || __ctype.widen('X') == __olds[1])) + { + __news[0] = __olds[0]; + __news[1] = __olds[1]; + __mod = 2; + __news += 2; + } + + } + _Traits::assign(__news, __plen, __fill); + _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod); + } + + template + _CharT* + __add_grouping(_CharT* __s, _CharT __sep, + const char* __gbeg, size_t __gsize, + const _CharT* __first, const _CharT* __last) + { + size_t __idx = 0; + size_t __ctr = 0; + + while (__last - __first > __gbeg[__idx] + && static_cast(__gbeg[__idx]) > 0 + && __gbeg[__idx] != __gnu_cxx::__numeric_traits::__max) + { + __last -= __gbeg[__idx]; + __idx < __gsize - 1 ? ++__idx : ++__ctr; + } + + while (__first != __last) + *__s++ = *__first++; + + while (__ctr--) + { + *__s++ = __sep; + for (char __i = __gbeg[__idx]; __i > 0; --__i) + *__s++ = *__first++; + } + + while (__idx--) + { + *__s++ = __sep; + for (char __i = __gbeg[__idx]; __i > 0; --__i) + *__s++ = *__first++; + } + + return __s; + } + + + + + extern template class __cxx11:: numpunct; + extern template class __cxx11:: numpunct_byname; + extern template class num_get; + extern template class num_put; + extern template class ctype_byname; + + extern template + const ctype& + use_facet >(const locale&); + + extern template + const numpunct& + use_facet >(const locale&); + + extern template + const num_put& + use_facet >(const locale&); + + extern template + const num_get& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + + extern template class __cxx11:: numpunct; + extern template class __cxx11:: numpunct_byname; + extern template class num_get; + extern template class num_put; + extern template class ctype_byname; + + extern template + const ctype& + use_facet >(const locale&); + + extern template + const numpunct& + use_facet >(const locale&); + + extern template + const num_put& + use_facet >(const locale&); + + extern template + const num_get& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + + + +} +# 2652 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 2 3 +# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 2 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + inline const _Facet& + __check_facet(const _Facet* __f) + { + if (!__f) + __throw_bad_cast(); + return *__f; + } +# 66 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3 + template + class basic_ios : public ios_base + { + public: + + + + + + + typedef _CharT char_type; + typedef typename _Traits::int_type int_type; + typedef typename _Traits::pos_type pos_type; + typedef typename _Traits::off_type off_type; + typedef _Traits traits_type; + + + + + + + typedef ctype<_CharT> __ctype_type; + typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> > + __num_put_type; + typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > + __num_get_type; + + + + protected: + basic_ostream<_CharT, _Traits>* _M_tie; + mutable char_type _M_fill; + mutable bool _M_fill_init; + basic_streambuf<_CharT, _Traits>* _M_streambuf; + + + const __ctype_type* _M_ctype; + + const __num_put_type* _M_num_put; + + const __num_get_type* _M_num_get; + + public: +# 117 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3 + explicit operator bool() const + { return !this->fail(); } + + + + + + bool + operator!() const + { return this->fail(); } +# 136 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3 + iostate + rdstate() const + { return _M_streambuf_state; } +# 147 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3 + void + clear(iostate __state = goodbit); + + + + + + + + void + setstate(iostate __state) + { this->clear(this->rdstate() | __state); } + + + + + void + _M_setstate(iostate __state) + { + + + _M_streambuf_state |= __state; + if (this->exceptions() & __state) + throw; + } + + + + + + + + bool + good() const + { return this->rdstate() == 0; } + + + + + + + + bool + eof() const + { return (this->rdstate() & eofbit) != 0; } +# 200 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3 + bool + fail() const + { return (this->rdstate() & (badbit | failbit)) != 0; } + + + + + + + + bool + bad() const + { return (this->rdstate() & badbit) != 0; } +# 221 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3 + iostate + exceptions() const + { return _M_exception; } +# 256 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3 + void + exceptions(iostate __except) + { + _M_exception = __except; + this->clear(_M_streambuf_state); + } + + + + + + + + explicit + basic_ios(basic_streambuf<_CharT, _Traits>* __sb) + : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0), + _M_ctype(0), _M_num_put(0), _M_num_get(0) + { this->init(__sb); } + + + + + + + + virtual + ~basic_ios() { } +# 294 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3 + basic_ostream<_CharT, _Traits>* + tie() const + { return _M_tie; } +# 306 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3 + basic_ostream<_CharT, _Traits>* + tie(basic_ostream<_CharT, _Traits>* __tiestr) + { + basic_ostream<_CharT, _Traits>* __old = _M_tie; + _M_tie = __tiestr; + return __old; + } + + + + + + + + basic_streambuf<_CharT, _Traits>* + rdbuf() const + { return _M_streambuf; } +# 346 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3 + basic_streambuf<_CharT, _Traits>* + rdbuf(basic_streambuf<_CharT, _Traits>* __sb); +# 360 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3 + basic_ios& + copyfmt(const basic_ios& __rhs); + + + + + + + + char_type + fill() const + { + if (!_M_fill_init) + { + _M_fill = this->widen(' '); + _M_fill_init = true; + } + return _M_fill; + } +# 389 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3 + char_type + fill(char_type __ch) + { + char_type __old = this->fill(); + _M_fill = __ch; + return __old; + } +# 409 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3 + locale + imbue(const locale& __loc); +# 429 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3 + char + narrow(char_type __c, char __dfault) const + { return __check_facet(_M_ctype).narrow(__c, __dfault); } +# 448 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3 + char_type + widen(char __c) const + { return __check_facet(_M_ctype).widen(__c); } + + protected: + + + + + + + + basic_ios() + : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false), + _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0) + { } + + + + + + + + void + init(basic_streambuf<_CharT, _Traits>* __sb); + + + basic_ios(const basic_ios&) = delete; + basic_ios& operator=(const basic_ios&) = delete; + + void + move(basic_ios& __rhs) + { + ios_base::_M_move(__rhs); + _M_cache_locale(_M_ios_locale); + this->tie(__rhs.tie(nullptr)); + _M_fill = __rhs._M_fill; + _M_fill_init = __rhs._M_fill_init; + _M_streambuf = nullptr; + } + + void + move(basic_ios&& __rhs) + { this->move(__rhs); } + + void + swap(basic_ios& __rhs) noexcept + { + ios_base::_M_swap(__rhs); + _M_cache_locale(_M_ios_locale); + __rhs._M_cache_locale(__rhs._M_ios_locale); + std::swap(_M_tie, __rhs._M_tie); + std::swap(_M_fill, __rhs._M_fill); + std::swap(_M_fill_init, __rhs._M_fill_init); + } + + void + set_rdbuf(basic_streambuf<_CharT, _Traits>* __sb) + { _M_streambuf = __sb; } + + + void + _M_cache_locale(const locale& __loc); + }; + + +} + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.tcc" 1 3 +# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.tcc" 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + void + basic_ios<_CharT, _Traits>::clear(iostate __state) + { + if (this->rdbuf()) + _M_streambuf_state = __state; + else + _M_streambuf_state = __state | badbit; + if (this->exceptions() & this->rdstate()) + __throw_ios_failure(("basic_ios::clear")); + } + + template + basic_streambuf<_CharT, _Traits>* + basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb) + { + basic_streambuf<_CharT, _Traits>* __old = _M_streambuf; + _M_streambuf = __sb; + this->clear(); + return __old; + } + + template + basic_ios<_CharT, _Traits>& + basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs) + { + + + if (this != &__rhs) + { + + + + + _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ? + _M_local_word : new _Words[__rhs._M_word_size]; + + + _Callback_list* __cb = __rhs._M_callbacks; + if (__cb) + __cb->_M_add_reference(); + _M_call_callbacks(erase_event); + if (_M_word != _M_local_word) + { + delete [] _M_word; + _M_word = 0; + } + _M_dispose_callbacks(); + + + _M_callbacks = __cb; + for (int __i = 0; __i < __rhs._M_word_size; ++__i) + __words[__i] = __rhs._M_word[__i]; + _M_word = __words; + _M_word_size = __rhs._M_word_size; + + this->flags(__rhs.flags()); + this->width(__rhs.width()); + this->precision(__rhs.precision()); + this->tie(__rhs.tie()); + this->fill(__rhs.fill()); + _M_ios_locale = __rhs.getloc(); + _M_cache_locale(_M_ios_locale); + + _M_call_callbacks(copyfmt_event); + + + this->exceptions(__rhs.exceptions()); + } + return *this; + } + + + template + locale + basic_ios<_CharT, _Traits>::imbue(const locale& __loc) + { + locale __old(this->getloc()); + ios_base::imbue(__loc); + _M_cache_locale(__loc); + if (this->rdbuf() != 0) + this->rdbuf()->pubimbue(__loc); + return __old; + } + + template + void + basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb) + { + + ios_base::_M_init(); + + + _M_cache_locale(_M_ios_locale); +# 146 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.tcc" 3 + _M_fill = _CharT(); + _M_fill_init = false; + + _M_tie = 0; + _M_exception = goodbit; + _M_streambuf = __sb; + _M_streambuf_state = __sb ? goodbit : badbit; + } + + template + void + basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc) + { + if (__builtin_expect(has_facet<__ctype_type>(__loc), true)) + _M_ctype = &use_facet<__ctype_type>(__loc); + else + _M_ctype = 0; + + if (__builtin_expect(has_facet<__num_put_type>(__loc), true)) + _M_num_put = &use_facet<__num_put_type>(__loc); + else + _M_num_put = 0; + + if (__builtin_expect(has_facet<__num_get_type>(__loc), true)) + _M_num_get = &use_facet<__num_get_type>(__loc); + else + _M_num_get = 0; + } + + + + + extern template class basic_ios; + + + extern template class basic_ios; + + + + +} +# 517 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 2 3 +# 45 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 2 3 +# 39 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 57 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + template + class basic_ostream : virtual public basic_ios<_CharT, _Traits> + { + public: + + typedef _CharT char_type; + typedef typename _Traits::int_type int_type; + typedef typename _Traits::pos_type pos_type; + typedef typename _Traits::off_type off_type; + typedef _Traits traits_type; + + + typedef basic_streambuf<_CharT, _Traits> __streambuf_type; + typedef basic_ios<_CharT, _Traits> __ios_type; + typedef basic_ostream<_CharT, _Traits> __ostream_type; + typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> > + __num_put_type; + typedef ctype<_CharT> __ctype_type; +# 83 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + explicit + basic_ostream(__streambuf_type* __sb) + { this->init(__sb); } + + + + + + + virtual + ~basic_ostream() { } + + + class sentry; + friend class sentry; +# 107 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + __ostream_type& + operator<<(__ostream_type& (*__pf)(__ostream_type&)) + { + + + + return __pf(*this); + } + + __ostream_type& + operator<<(__ios_type& (*__pf)(__ios_type&)) + { + + + + __pf(*this); + return *this; + } + + __ostream_type& + operator<<(ios_base& (*__pf) (ios_base&)) + { + + + + __pf(*this); + return *this; + } +# 165 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + __ostream_type& + operator<<(long __n) + { return _M_insert(__n); } + + __ostream_type& + operator<<(unsigned long __n) + { return _M_insert(__n); } + + __ostream_type& + operator<<(bool __n) + { return _M_insert(__n); } + + __ostream_type& + operator<<(short __n); + + __ostream_type& + operator<<(unsigned short __n) + { + + + return _M_insert(static_cast(__n)); + } + + __ostream_type& + operator<<(int __n); + + __ostream_type& + operator<<(unsigned int __n) + { + + + return _M_insert(static_cast(__n)); + } + + + __ostream_type& + operator<<(long long __n) + { return _M_insert(__n); } + + __ostream_type& + operator<<(unsigned long long __n) + { return _M_insert(__n); } +# 219 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + __ostream_type& + operator<<(double __f) + { return _M_insert(__f); } + + __ostream_type& + operator<<(float __f) + { + + + return _M_insert(static_cast(__f)); + } + + __ostream_type& + operator<<(long double __f) + { return _M_insert(__f); } +# 244 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + __ostream_type& + operator<<(const void* __p) + { return _M_insert(__p); } +# 269 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + __ostream_type& + operator<<(__streambuf_type* __sb); +# 302 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + __ostream_type& + put(char_type __c); + + + + + + + void + _M_write(const char_type* __s, streamsize __n) + { + const streamsize __put = this->rdbuf()->sputn(__s, __n); + if (__put != __n) + this->setstate(ios_base::badbit); + } +# 334 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + __ostream_type& + write(const char_type* __s, streamsize __n); +# 347 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + __ostream_type& + flush(); +# 357 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + pos_type + tellp(); +# 368 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + __ostream_type& + seekp(pos_type); +# 380 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + __ostream_type& + seekp(off_type, ios_base::seekdir); + + protected: + basic_ostream() + { this->init(0); } + + + + basic_ostream(basic_iostream<_CharT, _Traits>&) { } + + basic_ostream(const basic_ostream&) = delete; + + basic_ostream(basic_ostream&& __rhs) + : __ios_type() + { __ios_type::move(__rhs); } + + + + basic_ostream& operator=(const basic_ostream&) = delete; + + basic_ostream& + operator=(basic_ostream&& __rhs) + { + swap(__rhs); + return *this; + } + + void + swap(basic_ostream& __rhs) + { __ios_type::swap(__rhs); } + + + template + __ostream_type& + _M_insert(_ValueT __v); + }; +# 425 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + template + class basic_ostream<_CharT, _Traits>::sentry + { + + bool _M_ok; + basic_ostream<_CharT, _Traits>& _M_os; + + public: +# 444 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + explicit + sentry(basic_ostream<_CharT, _Traits>& __os); +# 454 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + ~sentry() + { + + if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception()) + { + + if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1) + _M_os.setstate(ios_base::badbit); + } + } +# 473 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + explicit + + operator bool() const + { return _M_ok; } + }; +# 495 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c) + { return __ostream_insert(__out, &__c, 1); } + + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __out, char __c) + { return (__out << __out.widen(__c)); } + + + template + inline basic_ostream& + operator<<(basic_ostream& __out, char __c) + { return __ostream_insert(__out, &__c, 1); } + + + template + inline basic_ostream& + operator<<(basic_ostream& __out, signed char __c) + { return (__out << static_cast(__c)); } + + template + inline basic_ostream& + operator<<(basic_ostream& __out, unsigned char __c) + { return (__out << static_cast(__c)); } +# 537 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s) + { + if (!__s) + __out.setstate(ios_base::badbit); + else + __ostream_insert(__out, __s, + static_cast(_Traits::length(__s))); + return __out; + } + + template + basic_ostream<_CharT, _Traits> & + operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s); + + + template + inline basic_ostream& + operator<<(basic_ostream& __out, const char* __s) + { + if (!__s) + __out.setstate(ios_base::badbit); + else + __ostream_insert(__out, __s, + static_cast(_Traits::length(__s))); + return __out; + } + + + template + inline basic_ostream& + operator<<(basic_ostream& __out, const signed char* __s) + { return (__out << reinterpret_cast(__s)); } + + template + inline basic_ostream & + operator<<(basic_ostream& __out, const unsigned char* __s) + { return (__out << reinterpret_cast(__s)); } +# 588 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + template + inline basic_ostream<_CharT, _Traits>& + endl(basic_ostream<_CharT, _Traits>& __os) + { return flush(__os.put(__os.widen('\n'))); } +# 600 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + template + inline basic_ostream<_CharT, _Traits>& + ends(basic_ostream<_CharT, _Traits>& __os) + { return __os.put(_CharT()); } + + + + + + + template + inline basic_ostream<_CharT, _Traits>& + flush(basic_ostream<_CharT, _Traits>& __os) + { return __os.flush(); } +# 626 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3 + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x) + { + __os << __x; + return __os; + } + + + +} + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ostream.tcc" 1 3 +# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ostream.tcc" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + basic_ostream<_CharT, _Traits>::sentry:: + sentry(basic_ostream<_CharT, _Traits>& __os) + : _M_ok(false), _M_os(__os) + { + + if (__os.tie() && __os.good()) + __os.tie()->flush(); + + if (__os.good()) + _M_ok = true; + else + __os.setstate(ios_base::failbit); + } + + template + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + _M_insert(_ValueT __v) + { + sentry __cerb(*this); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + const __num_put_type& __np = __check_facet(this->_M_num_put); + if (__np.put(*this, *this, this->fill(), __v).failed()) + __err |= ios_base::badbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + operator<<(short __n) + { + + + const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield; + if (__fmt == ios_base::oct || __fmt == ios_base::hex) + return _M_insert(static_cast(static_cast(__n))); + else + return _M_insert(static_cast(__n)); + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + operator<<(int __n) + { + + + const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield; + if (__fmt == ios_base::oct || __fmt == ios_base::hex) + return _M_insert(static_cast(static_cast(__n))); + else + return _M_insert(static_cast(__n)); + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + operator<<(__streambuf_type* __sbin) + { + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this); + if (__cerb && __sbin) + { + try + { + if (!__copy_streambufs(__sbin, this->rdbuf())) + __err |= ios_base::failbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::failbit); } + } + else if (!__sbin) + __err |= ios_base::badbit; + if (__err) + this->setstate(__err); + return *this; + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + put(char_type __c) + { + + + + + + + sentry __cerb(*this); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + const int_type __put = this->rdbuf()->sputc(__c); + if (traits_type::eq_int_type(__put, traits_type::eof())) + __err |= ios_base::badbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + write(const _CharT* __s, streamsize __n) + { + + + + + + + + sentry __cerb(*this); + if (__cerb) + { + try + { _M_write(__s, __n); } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + } + return *this; + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + flush() + { + + + + ios_base::iostate __err = ios_base::goodbit; + try + { + if (this->rdbuf() && this->rdbuf()->pubsync() == -1) + __err |= ios_base::badbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + return *this; + } + + template + typename basic_ostream<_CharT, _Traits>::pos_type + basic_ostream<_CharT, _Traits>:: + tellp() + { + pos_type __ret = pos_type(-1); + try + { + if (!this->fail()) + __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out); + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + return __ret; + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + seekp(pos_type __pos) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + if (!this->fail()) + { + + + const pos_type __p = this->rdbuf()->pubseekpos(__pos, + ios_base::out); + + + if (__p == pos_type(off_type(-1))) + __err |= ios_base::failbit; + } + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + return *this; + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + seekp(off_type __off, ios_base::seekdir __dir) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + if (!this->fail()) + { + + + const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir, + ios_base::out); + + + if (__p == pos_type(off_type(-1))) + __err |= ios_base::failbit; + } + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + return *this; + } + + template + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s) + { + if (!__s) + __out.setstate(ios_base::badbit); + else + { + + + const size_t __clen = char_traits::length(__s); + try + { + struct __ptr_guard + { + _CharT *__p; + __ptr_guard (_CharT *__ip): __p(__ip) { } + ~__ptr_guard() { delete[] __p; } + _CharT* __get() { return __p; } + } __pg (new _CharT[__clen]); + + _CharT *__ws = __pg.__get(); + for (size_t __i = 0; __i < __clen; ++__i) + __ws[__i] = __out.widen(__s[__i]); + __ostream_insert(__out, __ws, __clen); + } + catch(__cxxabiv1::__forced_unwind&) + { + __out._M_setstate(ios_base::badbit); + throw; + } + catch(...) + { __out._M_setstate(ios_base::badbit); } + } + return __out; + } + + + + + extern template class basic_ostream; + extern template ostream& endl(ostream&); + extern template ostream& ends(ostream&); + extern template ostream& flush(ostream&); + extern template ostream& operator<<(ostream&, char); + extern template ostream& operator<<(ostream&, unsigned char); + extern template ostream& operator<<(ostream&, signed char); + extern template ostream& operator<<(ostream&, const char*); + extern template ostream& operator<<(ostream&, const unsigned char*); + extern template ostream& operator<<(ostream&, const signed char*); + + extern template ostream& ostream::_M_insert(long); + extern template ostream& ostream::_M_insert(unsigned long); + extern template ostream& ostream::_M_insert(bool); + + extern template ostream& ostream::_M_insert(long long); + extern template ostream& ostream::_M_insert(unsigned long long); + + extern template ostream& ostream::_M_insert(double); + extern template ostream& ostream::_M_insert(long double); + extern template ostream& ostream::_M_insert(const void*); + + + extern template class basic_ostream; + extern template wostream& endl(wostream&); + extern template wostream& ends(wostream&); + extern template wostream& flush(wostream&); + extern template wostream& operator<<(wostream&, wchar_t); + extern template wostream& operator<<(wostream&, char); + extern template wostream& operator<<(wostream&, const wchar_t*); + extern template wostream& operator<<(wostream&, const char*); + + extern template wostream& wostream::_M_insert(long); + extern template wostream& wostream::_M_insert(unsigned long); + extern template wostream& wostream::_M_insert(bool); + + extern template wostream& wostream::_M_insert(long long); + extern template wostream& wostream::_M_insert(unsigned long long); + + extern template wostream& wostream::_M_insert(double); + extern template wostream& wostream::_M_insert(long double); + extern template wostream& wostream::_M_insert(const void*); + + + + +} +# 639 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 2 3 +# 65 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 1 3 +# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 57 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + template + class basic_istream : virtual public basic_ios<_CharT, _Traits> + { + public: + + typedef _CharT char_type; + typedef typename _Traits::int_type int_type; + typedef typename _Traits::pos_type pos_type; + typedef typename _Traits::off_type off_type; + typedef _Traits traits_type; + + + typedef basic_streambuf<_CharT, _Traits> __streambuf_type; + typedef basic_ios<_CharT, _Traits> __ios_type; + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > + __num_get_type; + typedef ctype<_CharT> __ctype_type; + + protected: + + + + + + streamsize _M_gcount; + + public: + + + + + + + + explicit + basic_istream(__streambuf_type* __sb) + : _M_gcount(streamsize(0)) + { this->init(__sb); } + + + + + + + virtual + ~basic_istream() + { _M_gcount = streamsize(0); } + + + class sentry; + friend class sentry; +# 119 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + __istream_type& + operator>>(__istream_type& (*__pf)(__istream_type&)) + { return __pf(*this); } + + __istream_type& + operator>>(__ios_type& (*__pf)(__ios_type&)) + { + __pf(*this); + return *this; + } + + __istream_type& + operator>>(ios_base& (*__pf)(ios_base&)) + { + __pf(*this); + return *this; + } +# 167 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + __istream_type& + operator>>(bool& __n) + { return _M_extract(__n); } + + __istream_type& + operator>>(short& __n); + + __istream_type& + operator>>(unsigned short& __n) + { return _M_extract(__n); } + + __istream_type& + operator>>(int& __n); + + __istream_type& + operator>>(unsigned int& __n) + { return _M_extract(__n); } + + __istream_type& + operator>>(long& __n) + { return _M_extract(__n); } + + __istream_type& + operator>>(unsigned long& __n) + { return _M_extract(__n); } + + + __istream_type& + operator>>(long long& __n) + { return _M_extract(__n); } + + __istream_type& + operator>>(unsigned long long& __n) + { return _M_extract(__n); } +# 213 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + __istream_type& + operator>>(float& __f) + { return _M_extract(__f); } + + __istream_type& + operator>>(double& __f) + { return _M_extract(__f); } + + __istream_type& + operator>>(long double& __f) + { return _M_extract(__f); } +# 234 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + __istream_type& + operator>>(void*& __p) + { return _M_extract(__p); } +# 258 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + __istream_type& + operator>>(__streambuf_type* __sb); +# 268 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + streamsize + gcount() const + { return _M_gcount; } +# 301 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + int_type + get(); +# 315 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + __istream_type& + get(char_type& __c); +# 342 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + __istream_type& + get(char_type* __s, streamsize __n, char_type __delim); +# 353 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + __istream_type& + get(char_type* __s, streamsize __n) + { return this->get(__s, __n, this->widen('\n')); } +# 376 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + __istream_type& + get(__streambuf_type& __sb, char_type __delim); +# 386 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + __istream_type& + get(__streambuf_type& __sb) + { return this->get(__sb, this->widen('\n')); } +# 415 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + __istream_type& + getline(char_type* __s, streamsize __n, char_type __delim); +# 426 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + __istream_type& + getline(char_type* __s, streamsize __n) + { return this->getline(__s, __n, this->widen('\n')); } +# 450 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + __istream_type& + ignore(streamsize __n, int_type __delim); + + __istream_type& + ignore(streamsize __n); + + __istream_type& + ignore(); +# 467 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + int_type + peek(); +# 485 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + __istream_type& + read(char_type* __s, streamsize __n); +# 504 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + streamsize + readsome(char_type* __s, streamsize __n); +# 521 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + __istream_type& + putback(char_type __c); +# 537 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + __istream_type& + unget(); +# 555 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + int + sync(); +# 570 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + pos_type + tellg(); +# 585 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + __istream_type& + seekg(pos_type); +# 601 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + __istream_type& + seekg(off_type, ios_base::seekdir); + + + protected: + basic_istream() + : _M_gcount(streamsize(0)) + { this->init(0); } + + + basic_istream(const basic_istream&) = delete; + + basic_istream(basic_istream&& __rhs) + : __ios_type(), _M_gcount(__rhs._M_gcount) + { + __ios_type::move(__rhs); + __rhs._M_gcount = 0; + } + + + + basic_istream& operator=(const basic_istream&) = delete; + + basic_istream& + operator=(basic_istream&& __rhs) + { + swap(__rhs); + return *this; + } + + void + swap(basic_istream& __rhs) + { + __ios_type::swap(__rhs); + std::swap(_M_gcount, __rhs._M_gcount); + } + + + template + __istream_type& + _M_extract(_ValueT& __v); + }; + + + template<> + basic_istream& + basic_istream:: + getline(char_type* __s, streamsize __n, char_type __delim); + + template<> + basic_istream& + basic_istream:: + ignore(streamsize __n); + + template<> + basic_istream& + basic_istream:: + ignore(streamsize __n, int_type __delim); + + + template<> + basic_istream& + basic_istream:: + getline(char_type* __s, streamsize __n, char_type __delim); + + template<> + basic_istream& + basic_istream:: + ignore(streamsize __n); + + template<> + basic_istream& + basic_istream:: + ignore(streamsize __n, int_type __delim); +# 685 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + template + class basic_istream<_CharT, _Traits>::sentry + { + + bool _M_ok; + + public: + + typedef _Traits traits_type; + typedef basic_streambuf<_CharT, _Traits> __streambuf_type; + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::__ctype_type __ctype_type; + typedef typename _Traits::int_type __int_type; +# 721 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + explicit + sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false); +# 732 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + explicit + + operator bool() const + { return _M_ok; } + }; +# 750 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + template + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c); + + template + inline basic_istream& + operator>>(basic_istream& __in, unsigned char& __c) + { return (__in >> reinterpret_cast(__c)); } + + template + inline basic_istream& + operator>>(basic_istream& __in, signed char& __c) + { return (__in >> reinterpret_cast(__c)); } +# 792 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + template + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s); + + + template<> + basic_istream& + operator>>(basic_istream& __in, char* __s); + + template + inline basic_istream& + operator>>(basic_istream& __in, unsigned char* __s) + { return (__in >> reinterpret_cast(__s)); } + + template + inline basic_istream& + operator>>(basic_istream& __in, signed char* __s) + { return (__in >> reinterpret_cast(__s)); } +# 823 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + template + class basic_iostream + : public basic_istream<_CharT, _Traits>, + public basic_ostream<_CharT, _Traits> + { + public: + + + + typedef _CharT char_type; + typedef typename _Traits::int_type int_type; + typedef typename _Traits::pos_type pos_type; + typedef typename _Traits::off_type off_type; + typedef _Traits traits_type; + + + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef basic_ostream<_CharT, _Traits> __ostream_type; + + + + + + + + explicit + basic_iostream(basic_streambuf<_CharT, _Traits>* __sb) + : __istream_type(__sb), __ostream_type(__sb) { } + + + + + virtual + ~basic_iostream() { } + + protected: + basic_iostream() + : __istream_type(), __ostream_type() { } + + + basic_iostream(const basic_iostream&) = delete; + + basic_iostream(basic_iostream&& __rhs) + : __istream_type(std::move(__rhs)), __ostream_type(*this) + { } + + + + basic_iostream& operator=(const basic_iostream&) = delete; + + basic_iostream& + operator=(basic_iostream&& __rhs) + { + swap(__rhs); + return *this; + } + + void + swap(basic_iostream& __rhs) + { __istream_type::swap(__rhs); } + + }; +# 906 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + template + basic_istream<_CharT, _Traits>& + ws(basic_istream<_CharT, _Traits>& __is); +# 922 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3 + template + inline basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x) + { + __is >> __x; + return __is; + } + + + +} + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/istream.tcc" 1 3 +# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/istream.tcc" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + basic_istream<_CharT, _Traits>::sentry:: + sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false) + { + ios_base::iostate __err = ios_base::goodbit; + if (__in.good()) + { + if (__in.tie()) + __in.tie()->flush(); + if (!__noskip && bool(__in.flags() & ios_base::skipws)) + { + const __int_type __eof = traits_type::eof(); + __streambuf_type* __sb = __in.rdbuf(); + __int_type __c = __sb->sgetc(); + + const __ctype_type& __ct = __check_facet(__in._M_ctype); + while (!traits_type::eq_int_type(__c, __eof) + && __ct.is(ctype_base::space, + traits_type::to_char_type(__c))) + __c = __sb->snextc(); + + + + + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + } + } + + if (__in.good() && __err == ios_base::goodbit) + _M_ok = true; + else + { + __err |= ios_base::failbit; + __in.setstate(__err); + } + } + + template + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + _M_extract(_ValueT& __v) + { + sentry __cerb(*this, false); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + const __num_get_type& __ng = __check_facet(this->_M_num_get); + __ng.get(*this, 0, *this, __err, __v); + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + operator>>(short& __n) + { + + + sentry __cerb(*this, false); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + long __l; + const __num_get_type& __ng = __check_facet(this->_M_num_get); + __ng.get(*this, 0, *this, __err, __l); + + + + if (__l < __gnu_cxx::__numeric_traits::__min) + { + __err |= ios_base::failbit; + __n = __gnu_cxx::__numeric_traits::__min; + } + else if (__l > __gnu_cxx::__numeric_traits::__max) + { + __err |= ios_base::failbit; + __n = __gnu_cxx::__numeric_traits::__max; + } + else + __n = short(__l); + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + operator>>(int& __n) + { + + + sentry __cerb(*this, false); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + long __l; + const __num_get_type& __ng = __check_facet(this->_M_num_get); + __ng.get(*this, 0, *this, __err, __l); + + + + if (__l < __gnu_cxx::__numeric_traits::__min) + { + __err |= ios_base::failbit; + __n = __gnu_cxx::__numeric_traits::__min; + } + else if (__l > __gnu_cxx::__numeric_traits::__max) + { + __err |= ios_base::failbit; + __n = __gnu_cxx::__numeric_traits::__max; + } + else + __n = int(__l); + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + operator>>(__streambuf_type* __sbout) + { + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this, false); + if (__cerb && __sbout) + { + try + { + bool __ineof; + if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof)) + __err |= ios_base::failbit; + if (__ineof) + __err |= ios_base::eofbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::failbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::failbit); } + } + else if (!__sbout) + __err |= ios_base::failbit; + if (__err) + this->setstate(__err); + return *this; + } + + template + typename basic_istream<_CharT, _Traits>::int_type + basic_istream<_CharT, _Traits>:: + get(void) + { + const int_type __eof = traits_type::eof(); + int_type __c = __eof; + _M_gcount = 0; + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this, true); + if (__cerb) + { + try + { + __c = this->rdbuf()->sbumpc(); + + if (!traits_type::eq_int_type(__c, __eof)) + _M_gcount = 1; + else + __err |= ios_base::eofbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + } + if (!_M_gcount) + __err |= ios_base::failbit; + if (__err) + this->setstate(__err); + return __c; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + get(char_type& __c) + { + _M_gcount = 0; + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this, true); + if (__cerb) + { + try + { + const int_type __cb = this->rdbuf()->sbumpc(); + + if (!traits_type::eq_int_type(__cb, traits_type::eof())) + { + _M_gcount = 1; + __c = traits_type::to_char_type(__cb); + } + else + __err |= ios_base::eofbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + } + if (!_M_gcount) + __err |= ios_base::failbit; + if (__err) + this->setstate(__err); + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + get(char_type* __s, streamsize __n, char_type __delim) + { + _M_gcount = 0; + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this, true); + if (__cerb) + { + try + { + const int_type __idelim = traits_type::to_int_type(__delim); + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + int_type __c = __sb->sgetc(); + + while (_M_gcount + 1 < __n + && !traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __idelim)) + { + *__s++ = traits_type::to_char_type(__c); + ++_M_gcount; + __c = __sb->snextc(); + } + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + } + + + if (__n > 0) + *__s = char_type(); + if (!_M_gcount) + __err |= ios_base::failbit; + if (__err) + this->setstate(__err); + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + get(__streambuf_type& __sb, char_type __delim) + { + _M_gcount = 0; + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this, true); + if (__cerb) + { + try + { + const int_type __idelim = traits_type::to_int_type(__delim); + const int_type __eof = traits_type::eof(); + __streambuf_type* __this_sb = this->rdbuf(); + int_type __c = __this_sb->sgetc(); + char_type __c2 = traits_type::to_char_type(__c); + + while (!traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __idelim) + && !traits_type::eq_int_type(__sb.sputc(__c2), __eof)) + { + ++_M_gcount; + __c = __this_sb->snextc(); + __c2 = traits_type::to_char_type(__c); + } + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + } + if (!_M_gcount) + __err |= ios_base::failbit; + if (__err) + this->setstate(__err); + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + getline(char_type* __s, streamsize __n, char_type __delim) + { + _M_gcount = 0; + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this, true); + if (__cerb) + { + try + { + const int_type __idelim = traits_type::to_int_type(__delim); + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + int_type __c = __sb->sgetc(); + + while (_M_gcount + 1 < __n + && !traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __idelim)) + { + *__s++ = traits_type::to_char_type(__c); + __c = __sb->snextc(); + ++_M_gcount; + } + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + else + { + if (traits_type::eq_int_type(__c, __idelim)) + { + __sb->sbumpc(); + ++_M_gcount; + } + else + __err |= ios_base::failbit; + } + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + } + + + if (__n > 0) + *__s = char_type(); + if (!_M_gcount) + __err |= ios_base::failbit; + if (__err) + this->setstate(__err); + return *this; + } + + + + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + ignore(void) + { + _M_gcount = 0; + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + + if (traits_type::eq_int_type(__sb->sbumpc(), __eof)) + __err |= ios_base::eofbit; + else + _M_gcount = 1; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + ignore(streamsize __n) + { + _M_gcount = 0; + sentry __cerb(*this, true); + if (__cerb && __n > 0) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + int_type __c = __sb->sgetc(); +# 513 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/istream.tcc" 3 + bool __large_ignore = false; + while (true) + { + while (_M_gcount < __n + && !traits_type::eq_int_type(__c, __eof)) + { + ++_M_gcount; + __c = __sb->snextc(); + } + if (__n == __gnu_cxx::__numeric_traits::__max + && !traits_type::eq_int_type(__c, __eof)) + { + _M_gcount = + __gnu_cxx::__numeric_traits::__min; + __large_ignore = true; + } + else + break; + } + + if (__large_ignore) + _M_gcount = __gnu_cxx::__numeric_traits::__max; + + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + ignore(streamsize __n, int_type __delim) + { + _M_gcount = 0; + sentry __cerb(*this, true); + if (__cerb && __n > 0) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + int_type __c = __sb->sgetc(); + + + bool __large_ignore = false; + while (true) + { + while (_M_gcount < __n + && !traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __delim)) + { + ++_M_gcount; + __c = __sb->snextc(); + } + if (__n == __gnu_cxx::__numeric_traits::__max + && !traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __delim)) + { + _M_gcount = + __gnu_cxx::__numeric_traits::__min; + __large_ignore = true; + } + else + break; + } + + if (__large_ignore) + _M_gcount = __gnu_cxx::__numeric_traits::__max; + + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + else if (traits_type::eq_int_type(__c, __delim)) + { + if (_M_gcount + < __gnu_cxx::__numeric_traits::__max) + ++_M_gcount; + __sb->sbumpc(); + } + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + typename basic_istream<_CharT, _Traits>::int_type + basic_istream<_CharT, _Traits>:: + peek(void) + { + int_type __c = traits_type::eof(); + _M_gcount = 0; + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + __c = this->rdbuf()->sgetc(); + if (traits_type::eq_int_type(__c, traits_type::eof())) + __err |= ios_base::eofbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return __c; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + read(char_type* __s, streamsize __n) + { + _M_gcount = 0; + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + _M_gcount = this->rdbuf()->sgetn(__s, __n); + if (_M_gcount != __n) + __err |= (ios_base::eofbit | ios_base::failbit); + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + streamsize + basic_istream<_CharT, _Traits>:: + readsome(char_type* __s, streamsize __n) + { + _M_gcount = 0; + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + + const streamsize __num = this->rdbuf()->in_avail(); + if (__num > 0) + _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n)); + else if (__num == -1) + __err |= ios_base::eofbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return _M_gcount; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + putback(char_type __c) + { + + + _M_gcount = 0; + + this->clear(this->rdstate() & ~ios_base::eofbit); + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + if (!__sb + || traits_type::eq_int_type(__sb->sputbackc(__c), __eof)) + __err |= ios_base::badbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + unget(void) + { + + + _M_gcount = 0; + + this->clear(this->rdstate() & ~ios_base::eofbit); + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + if (!__sb + || traits_type::eq_int_type(__sb->sungetc(), __eof)) + __err |= ios_base::badbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + int + basic_istream<_CharT, _Traits>:: + sync(void) + { + + + int __ret = -1; + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + __streambuf_type* __sb = this->rdbuf(); + if (__sb) + { + if (__sb->pubsync() == -1) + __err |= ios_base::badbit; + else + __ret = 0; + } + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return __ret; + } + + template + typename basic_istream<_CharT, _Traits>::pos_type + basic_istream<_CharT, _Traits>:: + tellg(void) + { + + + pos_type __ret = pos_type(-1); + sentry __cerb(*this, true); + if (__cerb) + { + try + { + if (!this->fail()) + __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, + ios_base::in); + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + } + return __ret; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + seekg(pos_type __pos) + { + + + + this->clear(this->rdstate() & ~ios_base::eofbit); + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + if (!this->fail()) + { + + const pos_type __p = this->rdbuf()->pubseekpos(__pos, + ios_base::in); + + + if (__p == pos_type(off_type(-1))) + __err |= ios_base::failbit; + } + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + seekg(off_type __off, ios_base::seekdir __dir) + { + + + + this->clear(this->rdstate() & ~ios_base::eofbit); + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + if (!this->fail()) + { + + const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir, + ios_base::in); + + + if (__p == pos_type(off_type(-1))) + __err |= ios_base::failbit; + } + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + + template + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c) + { + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::int_type __int_type; + + typename __istream_type::sentry __cerb(__in, false); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + const __int_type __cb = __in.rdbuf()->sbumpc(); + if (!_Traits::eq_int_type(__cb, _Traits::eof())) + __c = _Traits::to_char_type(__cb); + else + __err |= (ios_base::eofbit | ios_base::failbit); + } + catch(__cxxabiv1::__forced_unwind&) + { + __in._M_setstate(ios_base::badbit); + throw; + } + catch(...) + { __in._M_setstate(ios_base::badbit); } + if (__err) + __in.setstate(__err); + } + return __in; + } + + template + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s) + { + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef basic_streambuf<_CharT, _Traits> __streambuf_type; + typedef typename _Traits::int_type int_type; + typedef _CharT char_type; + typedef ctype<_CharT> __ctype_type; + + streamsize __extracted = 0; + ios_base::iostate __err = ios_base::goodbit; + typename __istream_type::sentry __cerb(__in, false); + if (__cerb) + { + try + { + + streamsize __num = __in.width(); + if (__num <= 0) + __num = __gnu_cxx::__numeric_traits::__max; + + const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); + + const int_type __eof = _Traits::eof(); + __streambuf_type* __sb = __in.rdbuf(); + int_type __c = __sb->sgetc(); + + while (__extracted < __num - 1 + && !_Traits::eq_int_type(__c, __eof) + && !__ct.is(ctype_base::space, + _Traits::to_char_type(__c))) + { + *__s++ = _Traits::to_char_type(__c); + ++__extracted; + __c = __sb->snextc(); + } + if (_Traits::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + + + + *__s = char_type(); + __in.width(0); + } + catch(__cxxabiv1::__forced_unwind&) + { + __in._M_setstate(ios_base::badbit); + throw; + } + catch(...) + { __in._M_setstate(ios_base::badbit); } + } + if (!__extracted) + __err |= ios_base::failbit; + if (__err) + __in.setstate(__err); + return __in; + } + + + template + basic_istream<_CharT, _Traits>& + ws(basic_istream<_CharT, _Traits>& __in) + { + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef basic_streambuf<_CharT, _Traits> __streambuf_type; + typedef typename __istream_type::int_type __int_type; + typedef ctype<_CharT> __ctype_type; + + const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); + const __int_type __eof = _Traits::eof(); + __streambuf_type* __sb = __in.rdbuf(); + __int_type __c = __sb->sgetc(); + + while (!_Traits::eq_int_type(__c, __eof) + && __ct.is(ctype_base::space, _Traits::to_char_type(__c))) + __c = __sb->snextc(); + + if (_Traits::eq_int_type(__c, __eof)) + __in.setstate(ios_base::eofbit); + return __in; + } + + + + + extern template class basic_istream; + extern template istream& ws(istream&); + extern template istream& operator>>(istream&, char&); + extern template istream& operator>>(istream&, char*); + extern template istream& operator>>(istream&, unsigned char&); + extern template istream& operator>>(istream&, signed char&); + extern template istream& operator>>(istream&, unsigned char*); + extern template istream& operator>>(istream&, signed char*); + + extern template istream& istream::_M_extract(unsigned short&); + extern template istream& istream::_M_extract(unsigned int&); + extern template istream& istream::_M_extract(long&); + extern template istream& istream::_M_extract(unsigned long&); + extern template istream& istream::_M_extract(bool&); + + extern template istream& istream::_M_extract(long long&); + extern template istream& istream::_M_extract(unsigned long long&); + + extern template istream& istream::_M_extract(float&); + extern template istream& istream::_M_extract(double&); + extern template istream& istream::_M_extract(long double&); + extern template istream& istream::_M_extract(void*&); + + extern template class basic_iostream; + + + extern template class basic_istream; + extern template wistream& ws(wistream&); + extern template wistream& operator>>(wistream&, wchar_t&); + extern template wistream& operator>>(wistream&, wchar_t*); + + extern template wistream& wistream::_M_extract(unsigned short&); + extern template wistream& wistream::_M_extract(unsigned int&); + extern template wistream& wistream::_M_extract(long&); + extern template wistream& wistream::_M_extract(unsigned long&); + extern template wistream& wistream::_M_extract(bool&); + + extern template wistream& wistream::_M_extract(long long&); + extern template wistream& wistream::_M_extract(unsigned long long&); + + extern template wistream& wistream::_M_extract(float&); + extern template wistream& wistream::_M_extract(double&); + extern template wistream& wistream::_M_extract(long double&); + extern template wistream& wistream::_M_extract(void*&); + + extern template class basic_iostream; + + + + +} +# 935 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 2 3 +# 66 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stream_iterator.h" 1 3 +# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stream_iterator.h" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stream_iterator.h" 3 + template, typename _Dist = ptrdiff_t> + class istream_iterator + : public iterator + { + public: + typedef _CharT char_type; + typedef _Traits traits_type; + typedef basic_istream<_CharT, _Traits> istream_type; + + private: + istream_type* _M_stream; + _Tp _M_value; + bool _M_ok; + + public: + + constexpr istream_iterator() + : _M_stream(0), _M_value(), _M_ok(false) {} + + + istream_iterator(istream_type& __s) + : _M_stream(&__s) + { _M_read(); } + + istream_iterator(const istream_iterator& __obj) + : _M_stream(__obj._M_stream), _M_value(__obj._M_value), + _M_ok(__obj._M_ok) + { } + + const _Tp& + operator*() const + { + + + ; + return _M_value; + } + + const _Tp* + operator->() const { return &(operator*()); } + + istream_iterator& + operator++() + { + + + ; + _M_read(); + return *this; + } + + istream_iterator + operator++(int) + { + + + ; + istream_iterator __tmp = *this; + _M_read(); + return __tmp; + } + + bool + _M_equal(const istream_iterator& __x) const + { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); } + + private: + void + _M_read() + { + _M_ok = (_M_stream && *_M_stream) ? true : false; + if (_M_ok) + { + *_M_stream >> _M_value; + _M_ok = *_M_stream ? true : false; + } + } + }; + + + template + inline bool + operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x, + const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y) + { return __x._M_equal(__y); } + + + template + inline bool + operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x, + const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y) + { return !__x._M_equal(__y); } +# 152 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stream_iterator.h" 3 + template > + class ostream_iterator + : public iterator + { + public: + + + typedef _CharT char_type; + typedef _Traits traits_type; + typedef basic_ostream<_CharT, _Traits> ostream_type; + + + private: + ostream_type* _M_stream; + const _CharT* _M_string; + + public: + + ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {} +# 183 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stream_iterator.h" 3 + ostream_iterator(ostream_type& __s, const _CharT* __c) + : _M_stream(&__s), _M_string(__c) { } + + + ostream_iterator(const ostream_iterator& __obj) + : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { } + + + + ostream_iterator& + operator=(const _Tp& __value) + { + + + ; + *_M_stream << __value; + if (_M_string) *_M_stream << _M_string; + return *this; + } + + ostream_iterator& + operator*() + { return *this; } + + ostream_iterator& + operator++() + { return *this; } + + ostream_iterator& + operator++(int) + { return *this; } + }; + + + + +} +# 67 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 2 3 +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayIterator.h" 2 + + + +namespace mozilla { +# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayIterator.h" +template +class ArrayIterator +{ +public: + typedef ArrayType array_type; + typedef ArrayIterator iterator_type; + typedef typename array_type::index_type index_type; + typedef typename RemoveReference::Type value_type; + typedef ptrdiff_t difference_type; + typedef value_type* pointer; + typedef value_type& reference; + typedef std::random_access_iterator_tag iterator_category; + +private: + const array_type* mArray; + index_type mIndex; + +public: + ArrayIterator() : mArray(nullptr), mIndex(0) {} + ArrayIterator(const iterator_type& aOther) + : mArray(aOther.mArray), mIndex(aOther.mIndex) {} + ArrayIterator(const array_type& aArray, index_type aIndex) + : mArray(&aArray), mIndex(aIndex) {} + + iterator_type& operator=(const iterator_type& aOther) { + mArray = aOther.mArray; + mIndex = aOther.mIndex; + return *this; + } + + bool operator==(const iterator_type& aRhs) const { + return mIndex == aRhs.mIndex; + } + bool operator!=(const iterator_type& aRhs) const { + return !(*this == aRhs); + } + bool operator<(const iterator_type& aRhs) const { + return mIndex < aRhs.mIndex; + } + bool operator>(const iterator_type& aRhs) const { + return mIndex > aRhs.mIndex; + } + bool operator<=(const iterator_type& aRhs) const { + return mIndex <= aRhs.mIndex; + } + bool operator>=(const iterator_type& aRhs) const { + return mIndex >= aRhs.mIndex; + } + + + + value_type* operator->() const { + return const_cast(&mArray->ElementAt(mIndex)); + } + Element operator*() const { + return const_cast(mArray->ElementAt(mIndex)); + } + + iterator_type& operator++() { + ++mIndex; + return *this; + } + iterator_type operator++(int) { + iterator_type it = *this; + ++*this; + return it; + } + iterator_type& operator--() { + --mIndex; + return *this; + } + iterator_type operator--(int) { + iterator_type it = *this; + --*this; + return it; + } + + iterator_type& operator+=(difference_type aDiff) { + mIndex += aDiff; + return *this; + } + iterator_type& operator-=(difference_type aDiff) { + mIndex -= aDiff; + return *this; + } + + iterator_type operator+(difference_type aDiff) const { + iterator_type it = *this; + it += aDiff; + return it; + } + iterator_type operator-(difference_type aDiff) const { + iterator_type it = *this; + it -= aDiff; + return it; + } + + difference_type operator-(const iterator_type& aOther) const { + return static_cast(mIndex) - + static_cast(aOther.mIndex); + } + + Element operator[](difference_type aIndex) const { + return *this->operator+(aIndex); + } +}; + +} +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2 + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BinarySearch.h" 1 +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BinarySearch.h" +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BinarySearch.h" 2 + +namespace mozilla { +# 66 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BinarySearch.h" +template +bool +BinarySearchIf(const Container& aContainer, size_t aBegin, size_t aEnd, + const Comparator& aCompare, size_t* aMatchOrInsertionPoint) +{ + do { } while (0); + + size_t low = aBegin; + size_t high = aEnd; + while (high != low) { + size_t middle = low + (high - low) / 2; + + + + const int result = aCompare(aContainer[middle]); + + if (result == 0) { + *aMatchOrInsertionPoint = middle; + return true; + } + + if (result < 0) { + high = middle; + } else { + low = middle + 1; + } + } + + *aMatchOrInsertionPoint = low; + return false; +} + +namespace detail { + +template +class BinarySearchDefaultComparator +{ +public: + explicit BinarySearchDefaultComparator(const T& aTarget) + : mTarget(aTarget) + {} + + template + int operator()(const U& aVal) const { + if (mTarget == aVal) { + return 0; + } + + if (mTarget < aVal) { + return -1; + } + + return 1; + } + +private: + const T& mTarget; +}; + +} + +template +bool +BinarySearch(const Container& aContainer, size_t aBegin, size_t aEnd, + T aTarget, size_t* aMatchOrInsertionPoint) +{ + return BinarySearchIf(aContainer, aBegin, aEnd, + detail::BinarySearchDefaultComparator(aTarget), + aMatchOrInsertionPoint); +} + +} +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2 + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h" 1 +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h" +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3 + + + + + +# 1 "/usr/include/math.h" 1 3 4 +# 28 "/usr/include/math.h" 3 4 +extern "C" { + + + +# 1 "/usr/include/bits/math-vector.h" 1 3 4 +# 25 "/usr/include/bits/math-vector.h" 3 4 +# 1 "/usr/include/bits/libm-simd-decl-stubs.h" 1 3 4 +# 26 "/usr/include/bits/math-vector.h" 2 3 4 +# 32 "/usr/include/math.h" 2 3 4 + + + +# 1 "/usr/include/bits/huge_val.h" 1 3 4 +# 36 "/usr/include/math.h" 2 3 4 + +# 1 "/usr/include/bits/huge_valf.h" 1 3 4 +# 38 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/bits/huge_vall.h" 1 3 4 +# 39 "/usr/include/math.h" 2 3 4 + + +# 1 "/usr/include/bits/inf.h" 1 3 4 +# 42 "/usr/include/math.h" 2 3 4 + + +# 1 "/usr/include/bits/nan.h" 1 3 4 +# 45 "/usr/include/math.h" 2 3 4 + + + +# 1 "/usr/include/bits/mathdef.h" 1 3 4 +# 28 "/usr/include/bits/mathdef.h" 3 4 +typedef float float_t; +typedef double double_t; +# 49 "/usr/include/math.h" 2 3 4 +# 83 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 54 "/usr/include/bits/mathcalls.h" 3 4 +extern double acos (double __x) throw (); extern double __acos (double __x) throw (); + +extern double asin (double __x) throw (); extern double __asin (double __x) throw (); + +extern double atan (double __x) throw (); extern double __atan (double __x) throw (); + +extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw (); + + + extern double cos (double __x) throw (); extern double __cos (double __x) throw (); + + extern double sin (double __x) throw (); extern double __sin (double __x) throw (); + +extern double tan (double __x) throw (); extern double __tan (double __x) throw (); + + + + +extern double cosh (double __x) throw (); extern double __cosh (double __x) throw (); + +extern double sinh (double __x) throw (); extern double __sinh (double __x) throw (); + +extern double tanh (double __x) throw (); extern double __tanh (double __x) throw (); + + + + + extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw (); + + + + + + +extern double acosh (double __x) throw (); extern double __acosh (double __x) throw (); + +extern double asinh (double __x) throw (); extern double __asinh (double __x) throw (); + +extern double atanh (double __x) throw (); extern double __atanh (double __x) throw (); + + + + + + + + extern double exp (double __x) throw (); extern double __exp (double __x) throw (); + + +extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw (); + + +extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw (); + + + extern double log (double __x) throw (); extern double __log (double __x) throw (); + + +extern double log10 (double __x) throw (); extern double __log10 (double __x) throw (); + + +extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw () __attribute__ ((__nonnull__ (2))); + + + + +extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw (); + +extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw (); + + + + + +extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw (); + + +extern double log1p (double __x) throw (); extern double __log1p (double __x) throw (); + + +extern double logb (double __x) throw (); extern double __logb (double __x) throw (); + + + + + + +extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw (); + + +extern double log2 (double __x) throw (); extern double __log2 (double __x) throw (); +# 153 "/usr/include/bits/mathcalls.h" 3 4 + extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw (); + + +extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw (); + + + + + +extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw (); + + + + + + +extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw (); +# 178 "/usr/include/bits/mathcalls.h" 3 4 +extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__)); + + +extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__)); + + +extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__)); + + +extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw (); + + + + +extern int __isinf (double __value) throw () __attribute__ ((__const__)); + + +extern int __finite (double __value) throw () __attribute__ ((__const__)); +# 208 "/usr/include/bits/mathcalls.h" 3 4 +extern int finite (double __value) throw () __attribute__ ((__const__)); + + +extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw (); + + + +extern double significand (double __x) throw (); extern double __significand (double __x) throw (); + + + + + +extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__)); + + + + + + +extern double nan (const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (const char *__tagb) throw () __attribute__ ((__const__)); + + + + + +extern int __isnan (double __value) throw () __attribute__ ((__const__)); +# 247 "/usr/include/bits/mathcalls.h" 3 4 +extern double j0 (double) throw (); extern double __j0 (double) throw (); +extern double j1 (double) throw (); extern double __j1 (double) throw (); +extern double jn (int, double) throw (); extern double __jn (int, double) throw (); +extern double y0 (double) throw (); extern double __y0 (double) throw (); +extern double y1 (double) throw (); extern double __y1 (double) throw (); +extern double yn (int, double) throw (); extern double __yn (int, double) throw (); + + + + + + +extern double erf (double) throw (); extern double __erf (double) throw (); +extern double erfc (double) throw (); extern double __erfc (double) throw (); +extern double lgamma (double) throw (); extern double __lgamma (double) throw (); + + + + + + +extern double tgamma (double) throw (); extern double __tgamma (double) throw (); + + + + + +extern double gamma (double) throw (); extern double __gamma (double) throw (); + + + + + + +extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw (); + + + + + + + +extern double rint (double __x) throw (); extern double __rint (double __x) throw (); + + +extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__)); + +extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); + + + + +extern double nextdown (double __x) throw (); extern double __nextdown (double __x) throw (); + +extern double nextup (double __x) throw (); extern double __nextup (double __x) throw (); + + + +extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw (); + + + +extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw (); + + + +extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw (); + + + + +extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw (); + + + +extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw (); + + + +extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__)); + + + +extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__)); + + + + +extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw (); + + + + + + +extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw (); +__extension__ +extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw (); + + + +extern long int lround (double __x) throw (); extern long int __lround (double __x) throw (); +__extension__ +extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw (); + + + +extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw (); + + +extern double fmax (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__)); + + +extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__)); + + + +extern int __fpclassify (double __value) throw () + __attribute__ ((__const__)); + + +extern int __signbit (double __value) throw () + __attribute__ ((__const__)); + + + +extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw (); +# 382 "/usr/include/bits/mathcalls.h" 3 4 +extern int __issignaling (double __value) throw () + __attribute__ ((__const__)); + + + + + + +extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw (); +# 84 "/usr/include/math.h" 2 3 4 +# 104 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 54 "/usr/include/bits/mathcalls.h" 3 4 +extern float acosf (float __x) throw (); extern float __acosf (float __x) throw (); + +extern float asinf (float __x) throw (); extern float __asinf (float __x) throw (); + +extern float atanf (float __x) throw (); extern float __atanf (float __x) throw (); + +extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw (); + + + extern float cosf (float __x) throw (); extern float __cosf (float __x) throw (); + + extern float sinf (float __x) throw (); extern float __sinf (float __x) throw (); + +extern float tanf (float __x) throw (); extern float __tanf (float __x) throw (); + + + + +extern float coshf (float __x) throw (); extern float __coshf (float __x) throw (); + +extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw (); + +extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw (); + + + + + extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw (); + + + + + + +extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw (); + +extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw (); + +extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw (); + + + + + + + + extern float expf (float __x) throw (); extern float __expf (float __x) throw (); + + +extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw (); + + +extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw (); + + + extern float logf (float __x) throw (); extern float __logf (float __x) throw (); + + +extern float log10f (float __x) throw (); extern float __log10f (float __x) throw (); + + +extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw () __attribute__ ((__nonnull__ (2))); + + + + +extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw (); + +extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw (); + + + + + +extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw (); + + +extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw (); + + +extern float logbf (float __x) throw (); extern float __logbf (float __x) throw (); + + + + + + +extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw (); + + +extern float log2f (float __x) throw (); extern float __log2f (float __x) throw (); +# 153 "/usr/include/bits/mathcalls.h" 3 4 + extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw (); + + +extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw (); + + + + + +extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw (); + + + + + + +extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw (); +# 178 "/usr/include/bits/mathcalls.h" 3 4 +extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__)); + + +extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__)); + + +extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__)); + + +extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw (); + + + + +extern int __isinff (float __value) throw () __attribute__ ((__const__)); + + +extern int __finitef (float __value) throw () __attribute__ ((__const__)); +# 204 "/usr/include/bits/mathcalls.h" 3 4 +extern int isinff (float __value) throw () __attribute__ ((__const__)); + + + +extern int finitef (float __value) throw () __attribute__ ((__const__)); + + +extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw (); + + + +extern float significandf (float __x) throw (); extern float __significandf (float __x) throw (); + + + + + +extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__)); + + + + + + +extern float nanf (const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (const char *__tagb) throw () __attribute__ ((__const__)); + + + + + +extern int __isnanf (float __value) throw () __attribute__ ((__const__)); + + + + + + +extern int isnanf (float __value) throw () __attribute__ ((__const__)); + + + + + +extern float j0f (float) throw (); extern float __j0f (float) throw (); +extern float j1f (float) throw (); extern float __j1f (float) throw (); +extern float jnf (int, float) throw (); extern float __jnf (int, float) throw (); +extern float y0f (float) throw (); extern float __y0f (float) throw (); +extern float y1f (float) throw (); extern float __y1f (float) throw (); +extern float ynf (int, float) throw (); extern float __ynf (int, float) throw (); + + + + + + +extern float erff (float) throw (); extern float __erff (float) throw (); +extern float erfcf (float) throw (); extern float __erfcf (float) throw (); +extern float lgammaf (float) throw (); extern float __lgammaf (float) throw (); + + + + + + +extern float tgammaf (float) throw (); extern float __tgammaf (float) throw (); + + + + + +extern float gammaf (float) throw (); extern float __gammaf (float) throw (); + + + + + + +extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw (); + + + + + + + +extern float rintf (float __x) throw (); extern float __rintf (float __x) throw (); + + +extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); + +extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); + + + + +extern float nextdownf (float __x) throw (); extern float __nextdownf (float __x) throw (); + +extern float nextupf (float __x) throw (); extern float __nextupf (float __x) throw (); + + + +extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw (); + + + +extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw (); + + + +extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw (); + + + + +extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw (); + + + +extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw (); + + + +extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__)); + + + +extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__)); + + + + +extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw (); + + + + + + +extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw (); +__extension__ +extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw (); + + + +extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw (); +__extension__ +extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw (); + + + +extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw (); + + +extern float fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); + + +extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__)); + + + +extern int __fpclassifyf (float __value) throw () + __attribute__ ((__const__)); + + +extern int __signbitf (float __value) throw () + __attribute__ ((__const__)); + + + +extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw (); +# 382 "/usr/include/bits/mathcalls.h" 3 4 +extern int __issignalingf (float __value) throw () + __attribute__ ((__const__)); + + + + + + +extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw (); +# 105 "/usr/include/math.h" 2 3 4 +# 151 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 54 "/usr/include/bits/mathcalls.h" 3 4 +extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw (); + +extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw (); + +extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw (); + +extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw (); + + + extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw (); + + extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw (); + +extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw (); + + + + +extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw (); + +extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw (); + +extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw (); + + + + + extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); + + + + + + +extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw (); + +extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw (); + +extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw (); + + + + + + + + extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw (); + + +extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw (); + + +extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw (); + + + extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw (); + + +extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw (); + + +extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw () __attribute__ ((__nonnull__ (2))); + + + + +extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw (); + +extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw (); + + + + + +extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw (); + + +extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw (); + + +extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw (); + + + + + + +extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw (); + + +extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw (); +# 153 "/usr/include/bits/mathcalls.h" 3 4 + extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw (); + + +extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw (); + + + + + +extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw (); + + + + + + +extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw (); +# 178 "/usr/include/bits/mathcalls.h" 3 4 +extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__)); + + +extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__)); + + +extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__)); + + +extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw (); + + + + +extern int __isinfl (long double __value) throw () __attribute__ ((__const__)); + + +extern int __finitel (long double __value) throw () __attribute__ ((__const__)); +# 204 "/usr/include/bits/mathcalls.h" 3 4 +extern int isinfl (long double __value) throw () __attribute__ ((__const__)); + + + +extern int finitel (long double __value) throw () __attribute__ ((__const__)); + + +extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw (); + + + +extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw (); + + + + + +extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); + + + + + + +extern long double nanl (const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (const char *__tagb) throw () __attribute__ ((__const__)); + + + + + +extern int __isnanl (long double __value) throw () __attribute__ ((__const__)); + + + + + + +extern int isnanl (long double __value) throw () __attribute__ ((__const__)); + + + + + +extern long double j0l (long double) throw (); extern long double __j0l (long double) throw (); +extern long double j1l (long double) throw (); extern long double __j1l (long double) throw (); +extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw (); +extern long double y0l (long double) throw (); extern long double __y0l (long double) throw (); +extern long double y1l (long double) throw (); extern long double __y1l (long double) throw (); +extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw (); + + + + + + +extern long double erfl (long double) throw (); extern long double __erfl (long double) throw (); +extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw (); +extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw (); + + + + + + +extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw (); + + + + + +extern long double gammal (long double) throw (); extern long double __gammal (long double) throw (); + + + + + + +extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw (); + + + + + + + +extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw (); + + +extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); + +extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); + + + + +extern long double nextdownl (long double __x) throw (); extern long double __nextdownl (long double __x) throw (); + +extern long double nextupl (long double __x) throw (); extern long double __nextupl (long double __x) throw (); + + + +extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw (); + + + +extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw (); + + + +extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw (); + + + + +extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw (); + + + +extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw (); + + + +extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__)); + + + +extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__)); + + + + +extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw (); + + + + + + +extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw (); +__extension__ +extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw (); + + + +extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw (); +__extension__ +extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw (); + + + +extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw (); + + +extern long double fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__)); + + +extern long double fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); + + + +extern int __fpclassifyl (long double __value) throw () + __attribute__ ((__const__)); + + +extern int __signbitl (long double __value) throw () + __attribute__ ((__const__)); + + + +extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw (); +# 382 "/usr/include/bits/mathcalls.h" 3 4 +extern int __issignalingl (long double __value) throw () + __attribute__ ((__const__)); + + + + + + +extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw (); +# 152 "/usr/include/math.h" 2 3 4 +# 168 "/usr/include/math.h" 3 4 +extern int signgam; +# 209 "/usr/include/math.h" 3 4 +enum + { + FP_NAN = + + 0, + FP_INFINITE = + + 1, + FP_ZERO = + + 2, + FP_SUBNORMAL = + + 3, + FP_NORMAL = + + 4 + }; +# 347 "/usr/include/math.h" 3 4 +typedef enum +{ + _IEEE_ = -1, + _SVID_, + _XOPEN_, + _POSIX_, + _ISOC_ +} _LIB_VERSION_TYPE; + + + + +extern _LIB_VERSION_TYPE _LIB_VERSION; +# 370 "/usr/include/math.h" 3 4 +struct __exception + + + + { + int type; + char *name; + double arg1; + double arg2; + double retval; + }; + + +extern int matherr (struct __exception *__exc) throw (); +# 534 "/usr/include/math.h" 3 4 +} +# 46 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 2 3 +# 77 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + inline constexpr double + abs(double __x) + { return __builtin_fabs(__x); } + + + + inline constexpr float + abs(float __x) + { return __builtin_fabsf(__x); } + + inline constexpr long double + abs(long double __x) + { return __builtin_fabsl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + abs(_Tp __x) + { return __builtin_fabs(__x); } + + using ::acos; + + + inline constexpr float + acos(float __x) + { return __builtin_acosf(__x); } + + inline constexpr long double + acos(long double __x) + { return __builtin_acosl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acos(_Tp __x) + { return __builtin_acos(__x); } + + using ::asin; + + + inline constexpr float + asin(float __x) + { return __builtin_asinf(__x); } + + inline constexpr long double + asin(long double __x) + { return __builtin_asinl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asin(_Tp __x) + { return __builtin_asin(__x); } + + using ::atan; + + + inline constexpr float + atan(float __x) + { return __builtin_atanf(__x); } + + inline constexpr long double + atan(long double __x) + { return __builtin_atanl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atan(_Tp __x) + { return __builtin_atan(__x); } + + using ::atan2; + + + inline constexpr float + atan2(float __y, float __x) + { return __builtin_atan2f(__y, __x); } + + inline constexpr long double + atan2(long double __y, long double __x) + { return __builtin_atan2l(__y, __x); } + + + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + atan2(_Tp __y, _Up __x) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return atan2(__type(__y), __type(__x)); + } + + using ::ceil; + + + inline constexpr float + ceil(float __x) + { return __builtin_ceilf(__x); } + + inline constexpr long double + ceil(long double __x) + { return __builtin_ceill(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ceil(_Tp __x) + { return __builtin_ceil(__x); } + + using ::cos; + + + inline constexpr float + cos(float __x) + { return __builtin_cosf(__x); } + + inline constexpr long double + cos(long double __x) + { return __builtin_cosl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cos(_Tp __x) + { return __builtin_cos(__x); } + + using ::cosh; + + + inline constexpr float + cosh(float __x) + { return __builtin_coshf(__x); } + + inline constexpr long double + cosh(long double __x) + { return __builtin_coshl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cosh(_Tp __x) + { return __builtin_cosh(__x); } + + using ::exp; + + + inline constexpr float + exp(float __x) + { return __builtin_expf(__x); } + + inline constexpr long double + exp(long double __x) + { return __builtin_expl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp(_Tp __x) + { return __builtin_exp(__x); } + + using ::fabs; + + + inline constexpr float + fabs(float __x) + { return __builtin_fabsf(__x); } + + inline constexpr long double + fabs(long double __x) + { return __builtin_fabsl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + fabs(_Tp __x) + { return __builtin_fabs(__x); } + + using ::floor; + + + inline constexpr float + floor(float __x) + { return __builtin_floorf(__x); } + + inline constexpr long double + floor(long double __x) + { return __builtin_floorl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + floor(_Tp __x) + { return __builtin_floor(__x); } + + using ::fmod; + + + inline constexpr float + fmod(float __x, float __y) + { return __builtin_fmodf(__x, __y); } + + inline constexpr long double + fmod(long double __x, long double __y) + { return __builtin_fmodl(__x, __y); } + + + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmod(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmod(__type(__x), __type(__y)); + } + + using ::frexp; + + + inline float + frexp(float __x, int* __exp) + { return __builtin_frexpf(__x, __exp); } + + inline long double + frexp(long double __x, int* __exp) + { return __builtin_frexpl(__x, __exp); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + frexp(_Tp __x, int* __exp) + { return __builtin_frexp(__x, __exp); } + + using ::ldexp; + + + inline constexpr float + ldexp(float __x, int __exp) + { return __builtin_ldexpf(__x, __exp); } + + inline constexpr long double + ldexp(long double __x, int __exp) + { return __builtin_ldexpl(__x, __exp); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ldexp(_Tp __x, int __exp) + { return __builtin_ldexp(__x, __exp); } + + using ::log; + + + inline constexpr float + log(float __x) + { return __builtin_logf(__x); } + + inline constexpr long double + log(long double __x) + { return __builtin_logl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log(_Tp __x) + { return __builtin_log(__x); } + + using ::log10; + + + inline constexpr float + log10(float __x) + { return __builtin_log10f(__x); } + + inline constexpr long double + log10(long double __x) + { return __builtin_log10l(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log10(_Tp __x) + { return __builtin_log10(__x); } + + using ::modf; + + + inline float + modf(float __x, float* __iptr) + { return __builtin_modff(__x, __iptr); } + + inline long double + modf(long double __x, long double* __iptr) + { return __builtin_modfl(__x, __iptr); } + + + using ::pow; + + + inline constexpr float + pow(float __x, float __y) + { return __builtin_powf(__x, __y); } + + inline constexpr long double + pow(long double __x, long double __y) + { return __builtin_powl(__x, __y); } +# 435 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3 + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + pow(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return pow(__type(__x), __type(__y)); + } + + using ::sin; + + + inline constexpr float + sin(float __x) + { return __builtin_sinf(__x); } + + inline constexpr long double + sin(long double __x) + { return __builtin_sinl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sin(_Tp __x) + { return __builtin_sin(__x); } + + using ::sinh; + + + inline constexpr float + sinh(float __x) + { return __builtin_sinhf(__x); } + + inline constexpr long double + sinh(long double __x) + { return __builtin_sinhl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sinh(_Tp __x) + { return __builtin_sinh(__x); } + + using ::sqrt; + + + inline constexpr float + sqrt(float __x) + { return __builtin_sqrtf(__x); } + + inline constexpr long double + sqrt(long double __x) + { return __builtin_sqrtl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sqrt(_Tp __x) + { return __builtin_sqrt(__x); } + + using ::tan; + + + inline constexpr float + tan(float __x) + { return __builtin_tanf(__x); } + + inline constexpr long double + tan(long double __x) + { return __builtin_tanl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tan(_Tp __x) + { return __builtin_tan(__x); } + + using ::tanh; + + + inline constexpr float + tanh(float __x) + { return __builtin_tanhf(__x); } + + inline constexpr long double + tanh(long double __x) + { return __builtin_tanhl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tanh(_Tp __x) + { return __builtin_tanh(__x); } + + +} +# 559 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + constexpr int + fpclassify(float __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + constexpr int + fpclassify(double __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + constexpr int + fpclassify(long double __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + int>::__type + fpclassify(_Tp __x) + { return __x != 0 ? 4 : 2; } + + + + constexpr bool + isfinite(float __x) + { return __builtin_isfinite(__x); } + + constexpr bool + isfinite(double __x) + { return __builtin_isfinite(__x); } + + constexpr bool + isfinite(long double __x) + { return __builtin_isfinite(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isfinite(_Tp __x) + { return true; } + + + + constexpr bool + isinf(float __x) + { return __builtin_isinf(__x); } + + + + + + constexpr bool + isinf(double __x) + { return __builtin_isinf(__x); } + + + constexpr bool + isinf(long double __x) + { return __builtin_isinf(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isinf(_Tp __x) + { return false; } + + + + constexpr bool + isnan(float __x) + { return __builtin_isnan(__x); } + + + + + + constexpr bool + isnan(double __x) + { return __builtin_isnan(__x); } + + + constexpr bool + isnan(long double __x) + { return __builtin_isnan(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isnan(_Tp __x) + { return false; } + + + + constexpr bool + isnormal(float __x) + { return __builtin_isnormal(__x); } + + constexpr bool + isnormal(double __x) + { return __builtin_isnormal(__x); } + + constexpr bool + isnormal(long double __x) + { return __builtin_isnormal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isnormal(_Tp __x) + { return __x != 0 ? true : false; } + + + + + constexpr bool + signbit(float __x) + { return __builtin_signbit(__x); } + + constexpr bool + signbit(double __x) + { return __builtin_signbit(__x); } + + constexpr bool + signbit(long double __x) + { return __builtin_signbit(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + signbit(_Tp __x) + { return __x < 0 ? true : false; } + + + + constexpr bool + isgreater(float __x, float __y) + { return __builtin_isgreater(__x, __y); } + + constexpr bool + isgreater(double __x, double __y) + { return __builtin_isgreater(__x, __y); } + + constexpr bool + isgreater(long double __x, long double __y) + { return __builtin_isgreater(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isgreater(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isgreater(__type(__x), __type(__y)); + } + + + + constexpr bool + isgreaterequal(float __x, float __y) + { return __builtin_isgreaterequal(__x, __y); } + + constexpr bool + isgreaterequal(double __x, double __y) + { return __builtin_isgreaterequal(__x, __y); } + + constexpr bool + isgreaterequal(long double __x, long double __y) + { return __builtin_isgreaterequal(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isgreaterequal(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isgreaterequal(__type(__x), __type(__y)); + } + + + + constexpr bool + isless(float __x, float __y) + { return __builtin_isless(__x, __y); } + + constexpr bool + isless(double __x, double __y) + { return __builtin_isless(__x, __y); } + + constexpr bool + isless(long double __x, long double __y) + { return __builtin_isless(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isless(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isless(__type(__x), __type(__y)); + } + + + + constexpr bool + islessequal(float __x, float __y) + { return __builtin_islessequal(__x, __y); } + + constexpr bool + islessequal(double __x, double __y) + { return __builtin_islessequal(__x, __y); } + + constexpr bool + islessequal(long double __x, long double __y) + { return __builtin_islessequal(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + islessequal(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_islessequal(__type(__x), __type(__y)); + } + + + + constexpr bool + islessgreater(float __x, float __y) + { return __builtin_islessgreater(__x, __y); } + + constexpr bool + islessgreater(double __x, double __y) + { return __builtin_islessgreater(__x, __y); } + + constexpr bool + islessgreater(long double __x, long double __y) + { return __builtin_islessgreater(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + islessgreater(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_islessgreater(__type(__x), __type(__y)); + } + + + + constexpr bool + isunordered(float __x, float __y) + { return __builtin_isunordered(__x, __y); } + + constexpr bool + isunordered(double __x, double __y) + { return __builtin_isunordered(__x, __y); } + + constexpr bool + isunordered(long double __x, long double __y) + { return __builtin_isunordered(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isunordered(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isunordered(__type(__x), __type(__y)); + } +# 981 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3 +} +# 1096 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + using ::double_t; + using ::float_t; + + + using ::acosh; + using ::acoshf; + using ::acoshl; + + using ::asinh; + using ::asinhf; + using ::asinhl; + + using ::atanh; + using ::atanhf; + using ::atanhl; + + using ::cbrt; + using ::cbrtf; + using ::cbrtl; + + using ::copysign; + using ::copysignf; + using ::copysignl; + + using ::erf; + using ::erff; + using ::erfl; + + using ::erfc; + using ::erfcf; + using ::erfcl; + + using ::exp2; + using ::exp2f; + using ::exp2l; + + using ::expm1; + using ::expm1f; + using ::expm1l; + + using ::fdim; + using ::fdimf; + using ::fdiml; + + using ::fma; + using ::fmaf; + using ::fmal; + + using ::fmax; + using ::fmaxf; + using ::fmaxl; + + using ::fmin; + using ::fminf; + using ::fminl; + + using ::hypot; + using ::hypotf; + using ::hypotl; + + using ::ilogb; + using ::ilogbf; + using ::ilogbl; + + using ::lgamma; + using ::lgammaf; + using ::lgammal; + + using ::llrint; + using ::llrintf; + using ::llrintl; + + using ::llround; + using ::llroundf; + using ::llroundl; + + using ::log1p; + using ::log1pf; + using ::log1pl; + + using ::log2; + using ::log2f; + using ::log2l; + + using ::logb; + using ::logbf; + using ::logbl; + + using ::lrint; + using ::lrintf; + using ::lrintl; + + using ::lround; + using ::lroundf; + using ::lroundl; + + using ::nan; + using ::nanf; + using ::nanl; + + using ::nearbyint; + using ::nearbyintf; + using ::nearbyintl; + + using ::nextafter; + using ::nextafterf; + using ::nextafterl; + + using ::nexttoward; + using ::nexttowardf; + using ::nexttowardl; + + using ::remainder; + using ::remainderf; + using ::remainderl; + + using ::remquo; + using ::remquof; + using ::remquol; + + using ::rint; + using ::rintf; + using ::rintl; + + using ::round; + using ::roundf; + using ::roundl; + + using ::scalbln; + using ::scalblnf; + using ::scalblnl; + + using ::scalbn; + using ::scalbnf; + using ::scalbnl; + + using ::tgamma; + using ::tgammaf; + using ::tgammal; + + using ::trunc; + using ::truncf; + using ::truncl; + + + + constexpr float + acosh(float __x) + { return __builtin_acoshf(__x); } + + constexpr long double + acosh(long double __x) + { return __builtin_acoshl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acosh(_Tp __x) + { return __builtin_acosh(__x); } + + + + constexpr float + asinh(float __x) + { return __builtin_asinhf(__x); } + + constexpr long double + asinh(long double __x) + { return __builtin_asinhl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asinh(_Tp __x) + { return __builtin_asinh(__x); } + + + + constexpr float + atanh(float __x) + { return __builtin_atanhf(__x); } + + constexpr long double + atanh(long double __x) + { return __builtin_atanhl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atanh(_Tp __x) + { return __builtin_atanh(__x); } + + + + constexpr float + cbrt(float __x) + { return __builtin_cbrtf(__x); } + + constexpr long double + cbrt(long double __x) + { return __builtin_cbrtl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cbrt(_Tp __x) + { return __builtin_cbrt(__x); } + + + + constexpr float + copysign(float __x, float __y) + { return __builtin_copysignf(__x, __y); } + + constexpr long double + copysign(long double __x, long double __y) + { return __builtin_copysignl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + copysign(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return copysign(__type(__x), __type(__y)); + } + + + + constexpr float + erf(float __x) + { return __builtin_erff(__x); } + + constexpr long double + erf(long double __x) + { return __builtin_erfl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erf(_Tp __x) + { return __builtin_erf(__x); } + + + + constexpr float + erfc(float __x) + { return __builtin_erfcf(__x); } + + constexpr long double + erfc(long double __x) + { return __builtin_erfcl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erfc(_Tp __x) + { return __builtin_erfc(__x); } + + + + constexpr float + exp2(float __x) + { return __builtin_exp2f(__x); } + + constexpr long double + exp2(long double __x) + { return __builtin_exp2l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp2(_Tp __x) + { return __builtin_exp2(__x); } + + + + constexpr float + expm1(float __x) + { return __builtin_expm1f(__x); } + + constexpr long double + expm1(long double __x) + { return __builtin_expm1l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + expm1(_Tp __x) + { return __builtin_expm1(__x); } + + + + constexpr float + fdim(float __x, float __y) + { return __builtin_fdimf(__x, __y); } + + constexpr long double + fdim(long double __x, long double __y) + { return __builtin_fdiml(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fdim(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fdim(__type(__x), __type(__y)); + } + + + + constexpr float + fma(float __x, float __y, float __z) + { return __builtin_fmaf(__x, __y, __z); } + + constexpr long double + fma(long double __x, long double __y, long double __z) + { return __builtin_fmal(__x, __y, __z); } + + + + template + constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type + fma(_Tp __x, _Up __y, _Vp __z) + { + typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; + return fma(__type(__x), __type(__y), __type(__z)); + } + + + + constexpr float + fmax(float __x, float __y) + { return __builtin_fmaxf(__x, __y); } + + constexpr long double + fmax(long double __x, long double __y) + { return __builtin_fmaxl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmax(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmax(__type(__x), __type(__y)); + } + + + + constexpr float + fmin(float __x, float __y) + { return __builtin_fminf(__x, __y); } + + constexpr long double + fmin(long double __x, long double __y) + { return __builtin_fminl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmin(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmin(__type(__x), __type(__y)); + } + + + + constexpr float + hypot(float __x, float __y) + { return __builtin_hypotf(__x, __y); } + + constexpr long double + hypot(long double __x, long double __y) + { return __builtin_hypotl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + hypot(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return hypot(__type(__x), __type(__y)); + } + + + + constexpr int + ilogb(float __x) + { return __builtin_ilogbf(__x); } + + constexpr int + ilogb(long double __x) + { return __builtin_ilogbl(__x); } + + + + template + constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + int>::__type + ilogb(_Tp __x) + { return __builtin_ilogb(__x); } + + + + constexpr float + lgamma(float __x) + { return __builtin_lgammaf(__x); } + + constexpr long double + lgamma(long double __x) + { return __builtin_lgammal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + lgamma(_Tp __x) + { return __builtin_lgamma(__x); } + + + + constexpr long long + llrint(float __x) + { return __builtin_llrintf(__x); } + + constexpr long long + llrint(long double __x) + { return __builtin_llrintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llrint(_Tp __x) + { return __builtin_llrint(__x); } + + + + constexpr long long + llround(float __x) + { return __builtin_llroundf(__x); } + + constexpr long long + llround(long double __x) + { return __builtin_llroundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llround(_Tp __x) + { return __builtin_llround(__x); } + + + + constexpr float + log1p(float __x) + { return __builtin_log1pf(__x); } + + constexpr long double + log1p(long double __x) + { return __builtin_log1pl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log1p(_Tp __x) + { return __builtin_log1p(__x); } + + + + + constexpr float + log2(float __x) + { return __builtin_log2f(__x); } + + constexpr long double + log2(long double __x) + { return __builtin_log2l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log2(_Tp __x) + { return __builtin_log2(__x); } + + + + constexpr float + logb(float __x) + { return __builtin_logbf(__x); } + + constexpr long double + logb(long double __x) + { return __builtin_logbl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + logb(_Tp __x) + { return __builtin_logb(__x); } + + + + constexpr long + lrint(float __x) + { return __builtin_lrintf(__x); } + + constexpr long + lrint(long double __x) + { return __builtin_lrintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lrint(_Tp __x) + { return __builtin_lrint(__x); } + + + + constexpr long + lround(float __x) + { return __builtin_lroundf(__x); } + + constexpr long + lround(long double __x) + { return __builtin_lroundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lround(_Tp __x) + { return __builtin_lround(__x); } + + + + constexpr float + nearbyint(float __x) + { return __builtin_nearbyintf(__x); } + + constexpr long double + nearbyint(long double __x) + { return __builtin_nearbyintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nearbyint(_Tp __x) + { return __builtin_nearbyint(__x); } + + + + constexpr float + nextafter(float __x, float __y) + { return __builtin_nextafterf(__x, __y); } + + constexpr long double + nextafter(long double __x, long double __y) + { return __builtin_nextafterl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + nextafter(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return nextafter(__type(__x), __type(__y)); + } + + + + constexpr float + nexttoward(float __x, long double __y) + { return __builtin_nexttowardf(__x, __y); } + + constexpr long double + nexttoward(long double __x, long double __y) + { return __builtin_nexttowardl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nexttoward(_Tp __x, long double __y) + { return __builtin_nexttoward(__x, __y); } + + + + constexpr float + remainder(float __x, float __y) + { return __builtin_remainderf(__x, __y); } + + constexpr long double + remainder(long double __x, long double __y) + { return __builtin_remainderl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remainder(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remainder(__type(__x), __type(__y)); + } + + + + inline float + remquo(float __x, float __y, int* __pquo) + { return __builtin_remquof(__x, __y, __pquo); } + + inline long double + remquo(long double __x, long double __y, int* __pquo) + { return __builtin_remquol(__x, __y, __pquo); } + + + + template + inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remquo(_Tp __x, _Up __y, int* __pquo) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remquo(__type(__x), __type(__y), __pquo); + } + + + + constexpr float + rint(float __x) + { return __builtin_rintf(__x); } + + constexpr long double + rint(long double __x) + { return __builtin_rintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + rint(_Tp __x) + { return __builtin_rint(__x); } + + + + constexpr float + round(float __x) + { return __builtin_roundf(__x); } + + constexpr long double + round(long double __x) + { return __builtin_roundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + round(_Tp __x) + { return __builtin_round(__x); } + + + + constexpr float + scalbln(float __x, long __ex) + { return __builtin_scalblnf(__x, __ex); } + + constexpr long double + scalbln(long double __x, long __ex) + { return __builtin_scalblnl(__x, __ex); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbln(_Tp __x, long __ex) + { return __builtin_scalbln(__x, __ex); } + + + + constexpr float + scalbn(float __x, int __ex) + { return __builtin_scalbnf(__x, __ex); } + + constexpr long double + scalbn(long double __x, int __ex) + { return __builtin_scalbnl(__x, __ex); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbn(_Tp __x, int __ex) + { return __builtin_scalbn(__x, __ex); } + + + + constexpr float + tgamma(float __x) + { return __builtin_tgammaf(__x); } + + constexpr long double + tgamma(long double __x) + { return __builtin_tgammal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tgamma(_Tp __x) + { return __builtin_tgamma(__x); } + + + + constexpr float + trunc(float __x) + { return __builtin_truncf(__x); } + + constexpr long double + trunc(long double __x) + { return __builtin_truncl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + trunc(_Tp __x) + { return __builtin_trunc(__x); } + + + +} +# 1889 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3 +} +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h" 2 + + + +namespace mozilla { + + +template +__attribute__((always_inline)) inline IntegerType +EuclidGCD(IntegerType aA, IntegerType aB) +{ + + + do { } while (0); + do { } while (0); + + while (aA != aB) { + if (aA > aB) { + aA = aA - aB; + } else { + aB = aB - aA; + } + } + + return aA; +} + + +template +__attribute__((always_inline)) inline IntegerType +EuclidLCM(IntegerType aA, IntegerType aB) +{ + + return (aA / EuclidGCD(aA, aB)) * aB; +} + +namespace detail { + +template +struct AllowDeprecatedAbsFixed : FalseType {}; + +template<> struct AllowDeprecatedAbsFixed : TrueType {}; +template<> struct AllowDeprecatedAbsFixed : TrueType {}; + +template +struct AllowDeprecatedAbs : AllowDeprecatedAbsFixed {}; + +template<> struct AllowDeprecatedAbs : TrueType {}; +template<> struct AllowDeprecatedAbs : TrueType {}; + +} + + + +template +inline typename mozilla::EnableIf::value, T>::Type +DeprecatedAbs(const T aValue) +{ +# 82 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h" + do { } while (0); + + + return aValue >= 0 ? aValue : -aValue; +} + +namespace detail { + + + + + +template +struct AbsReturnTypeFixed; + +template<> struct AbsReturnTypeFixed { typedef uint8_t Type; }; +template<> struct AbsReturnTypeFixed { typedef uint16_t Type; }; +template<> struct AbsReturnTypeFixed { typedef uint32_t Type; }; +template<> struct AbsReturnTypeFixed { typedef uint64_t Type; }; + +template +struct AbsReturnType : AbsReturnTypeFixed {}; + +template<> struct AbsReturnType : + EnableIf {}; +template<> struct AbsReturnType { typedef unsigned char Type; }; +template<> struct AbsReturnType { typedef unsigned short Type; }; +template<> struct AbsReturnType { typedef unsigned int Type; }; +template<> struct AbsReturnType { typedef unsigned long Type; }; +template<> struct AbsReturnType { typedef unsigned long long Type; }; +template<> struct AbsReturnType { typedef float Type; }; +template<> struct AbsReturnType { typedef double Type; }; +template<> struct AbsReturnType { typedef long double Type; }; + +} + +template +inline typename detail::AbsReturnType::Type +Abs(const T aValue) +{ + typedef typename detail::AbsReturnType::Type ReturnType; + return aValue >= 0 ? ReturnType(aValue) : ~ReturnType(aValue) + 1; +} + +template<> +inline float +Abs(const float aFloat) +{ + return std::fabs(aFloat); +} + +template<> +inline double +Abs(const double aDouble) +{ + return std::fabs(aDouble); +} + +template<> +inline long double +Abs(const long double aLongDouble) +{ + return std::fabs(aLongDouble); +} + +} +# 163 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h" +namespace mozilla { + +namespace detail { +# 250 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h" +inline uint_fast8_t +CountLeadingZeroes32(uint32_t aValue) +{ + return __builtin_clz(aValue); +} + +inline uint_fast8_t +CountTrailingZeroes32(uint32_t aValue) +{ + return __builtin_ctz(aValue); +} + +inline uint_fast8_t +CountPopulation32(uint32_t aValue) +{ + return __builtin_popcount(aValue); +} + +inline uint_fast8_t +CountPopulation64(uint64_t aValue) +{ + return __builtin_popcountll(aValue); +} + +inline uint_fast8_t +CountLeadingZeroes64(uint64_t aValue) +{ + return __builtin_clzll(aValue); +} + +inline uint_fast8_t +CountTrailingZeroes64(uint64_t aValue) +{ + return __builtin_ctzll(aValue); +} +# 296 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h" +} +# 309 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h" +inline uint_fast8_t +CountLeadingZeroes32(uint32_t aValue) +{ + do { } while (0); + return detail::CountLeadingZeroes32(aValue); +} +# 327 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h" +inline uint_fast8_t +CountTrailingZeroes32(uint32_t aValue) +{ + do { } while (0); + return detail::CountTrailingZeroes32(aValue); +} + + + + +inline uint_fast8_t +CountPopulation32(uint32_t aValue) +{ + return detail::CountPopulation32(aValue); +} + + +inline uint_fast8_t +CountPopulation64(uint64_t aValue) +{ + return detail::CountPopulation64(aValue); +} + + +inline uint_fast8_t +CountLeadingZeroes64(uint64_t aValue) +{ + do { } while (0); + return detail::CountLeadingZeroes64(aValue); +} + + +inline uint_fast8_t +CountTrailingZeroes64(uint64_t aValue) +{ + do { } while (0); + return detail::CountTrailingZeroes64(aValue); +} + +namespace detail { + +template +class CeilingLog2; + +template +class CeilingLog2 +{ +public: + static uint_fast8_t compute(const T aValue) + { + + return aValue <= 1 ? 0u : 32u - CountLeadingZeroes32(aValue - 1); + } +}; + +template +class CeilingLog2 +{ +public: + static uint_fast8_t compute(const T aValue) + { + + return aValue <= 1 ? 0u : 64u - CountLeadingZeroes64(aValue - 1); + } +}; + +} +# 404 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h" +template +inline uint_fast8_t +CeilingLog2(const T aValue) +{ + return detail::CeilingLog2::compute(aValue); +} + + +inline uint_fast8_t +CeilingLog2Size(size_t aValue) +{ + return CeilingLog2(aValue); +} + +namespace detail { + +template +class FloorLog2; + +template +class FloorLog2 +{ +public: + static uint_fast8_t compute(const T aValue) + { + return 31u - CountLeadingZeroes32(aValue | 1); + } +}; + +template +class FloorLog2 +{ +public: + static uint_fast8_t compute(const T aValue) + { + return 63u - CountLeadingZeroes64(aValue | 1); + } +}; + +} +# 453 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h" +template +inline uint_fast8_t +FloorLog2(const T aValue) +{ + return detail::FloorLog2::compute(aValue); +} + + +inline uint_fast8_t +FloorLog2Size(size_t aValue) +{ + return FloorLog2(aValue); +} + + + + + +inline size_t +RoundUpPow2(size_t aValue) +{ + do { } while (0); + + return size_t(1) << CeilingLog2(aValue); +} + + + + +template +inline T +RotateLeft(const T aValue, uint_fast8_t aShift) +{ + do { } while (0); + do { } while (0); + + + + + static_assert(IsUnsigned::value, "Rotates require unsigned values"); + return (aValue << aShift) | (aValue >> (sizeof(T) * 8 - aShift)); +} + + + + +template +inline T +RotateRight(const T aValue, uint_fast8_t aShift) +{ + do { } while (0); + do { } while (0); + + + + + static_assert(IsUnsigned::value, "Rotates require unsigned values"); + return (aValue >> aShift) | (aValue << (sizeof(T) * 8 - aShift)); +} + + + + + +template +constexpr bool +IsPowerOfTwo(T x) +{ + static_assert(IsUnsigned::value, + "IsPowerOfTwo requires unsigned values"); + return x && (x & (x - 1)) == 0; +} + +template +inline T +Clamp(const T aValue, const T aMin, const T aMax) +{ + static_assert(IsIntegral::value, + "Clamp accepts only integral types, so that it doesn't have" + " to distinguish differently-signed zeroes (which users may" + " or may not care to distinguish, likely at a perf cost) or" + " to decide how to clamp NaN or a range with a NaN" + " endpoint."); + do { } while (0); + + if (aValue <= aMin) + return aMin; + if (aValue >= aMax) + return aMax; + return aValue; +} + +} +# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MemoryReporting.h" 1 +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MemoryReporting.h" +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MemoryReporting.h" 2 + + + +namespace mozilla { + + + + + +typedef size_t (*MallocSizeOf)(const void* p); + +} + + + +typedef size_t (*MozMallocSizeOf)(const void* p); +# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2 + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ReverseIterator.h" 1 +# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ReverseIterator.h" +namespace mozilla { + +template +class ReverseIterator +{ +public: + template + explicit ReverseIterator(Iterator aIter) + : mCurrent(aIter) { } + + template + ReverseIterator(const ReverseIterator& aOther) + : mCurrent(aOther.mCurrent) { } + + decltype(*DeclVal()) operator*() const + { + IteratorT tmp = mCurrent; + return *--tmp; + } + + + + ReverseIterator& operator++() { --mCurrent; return *this; } + ReverseIterator& operator--() { ++mCurrent; return *this; } + ReverseIterator operator++(int) { auto ret = *this; mCurrent--; return ret; } + ReverseIterator operator--(int) { auto ret = *this; mCurrent++; return ret; } + + + + template + friend bool operator==(const ReverseIterator& aIter1, + const ReverseIterator& aIter2); + template + friend bool operator!=(const ReverseIterator& aIter1, + const ReverseIterator& aIter2); + template + friend bool operator<(const ReverseIterator& aIter1, + const ReverseIterator& aIter2); + template + friend bool operator<=(const ReverseIterator& aIter1, + const ReverseIterator& aIter2); + template + friend bool operator>(const ReverseIterator& aIter1, + const ReverseIterator& aIter2); + template + friend bool operator>=(const ReverseIterator& aIter1, + const ReverseIterator& aIter2); + +private: + IteratorT mCurrent; +}; + +template +bool +operator==(const ReverseIterator& aIter1, + const ReverseIterator& aIter2) +{ + return aIter1.mCurrent == aIter2.mCurrent; +} + +template +bool +operator!=(const ReverseIterator& aIter1, + const ReverseIterator& aIter2) +{ + return aIter1.mCurrent != aIter2.mCurrent; +} + +template +bool +operator<(const ReverseIterator& aIter1, + const ReverseIterator& aIter2) +{ + return aIter1.mCurrent > aIter2.mCurrent; +} + +template +bool +operator<=(const ReverseIterator& aIter1, + const ReverseIterator& aIter2) +{ + return aIter1.mCurrent >= aIter2.mCurrent; +} + +template +bool +operator>(const ReverseIterator& aIter1, + const ReverseIterator& aIter2) +{ + return aIter1.mCurrent < aIter2.mCurrent; +} + +template +bool +operator>=(const ReverseIterator& aIter1, + const ReverseIterator& aIter2) +{ + return aIter1.mCurrent <= aIter2.mCurrent; +} + +namespace detail { + +template +class IteratorRange +{ +public: + typedef IteratorT iterator; + typedef IteratorT const_iterator; + typedef ReverseIterator reverse_iterator; + typedef ReverseIterator const_reverse_iterator; + + template + IteratorRange(Iterator1 aIterBegin, Iterator2 aIterEnd) + : mIterBegin(aIterBegin), mIterEnd(aIterEnd) { } + + template + IteratorRange(const IteratorRange& aOther) + : mIterBegin(aOther.mIterBegin), mIterEnd(aOther.mIterEnd) { } + + iterator begin() const { return mIterBegin; } + const_iterator cbegin() const { return begin(); } + iterator end() const { return mIterEnd; } + const_iterator cend() const { return end(); } + reverse_iterator rbegin() const { return reverse_iterator(mIterEnd); } + const_reverse_iterator crbegin() const { return rbegin(); } + reverse_iterator rend() const { return reverse_iterator(mIterBegin); } + const_reverse_iterator crend() const { return rend(); } + +private: + IteratorT mIterBegin; + IteratorT mIterEnd; +}; + +} + +template +detail::IteratorRange +Reversed(Range& aRange) +{ + return {aRange.rbegin(), aRange.rend()}; +} + +template +detail::IteratorRange +Reversed(const Range& aRange) +{ + return {aRange.rbegin(), aRange.rend()}; +} + +} +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2 + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" 1 +# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Array.h" 1 +# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Array.h" +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 +# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Array.h" 2 + +namespace mozilla { + +template +class Array +{ + T mArr[Length]; + +public: + Array() {} + + template + Array(Args&&... aArgs) + : mArr{mozilla::Forward(aArgs)...} + { + static_assert(sizeof...(aArgs) == Length, + "The number of arguments should be equal to the template parameter Length"); + } + + T& operator[](size_t aIndex) + { + do { } while (0); + return mArr[aIndex]; + } + + const T& operator[](size_t aIndex) const + { + do { } while (0); + return mArr[aIndex]; + } + + bool operator==(const Array& aOther) const + { + for (size_t i = 0; i < Length; i++) { + if (mArr[i] != aOther[i]) { + return false; + } + } + return true; + } + + typedef T* iterator; + typedef const T* const_iterator; + typedef ReverseIterator reverse_iterator; + typedef ReverseIterator const_reverse_iterator; + + + iterator begin() { return mArr; } + const_iterator begin() const { return mArr; } + const_iterator cbegin() const { return begin(); } + iterator end() { return mArr + Length; } + const_iterator end() const { return mArr + Length; } + const_iterator cend() const { return end(); } + + + reverse_iterator rbegin() { return reverse_iterator(end()); } + const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } + const_reverse_iterator crbegin() const { return rbegin(); } + reverse_iterator rend() { return reverse_iterator(begin()); } + const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } + const_reverse_iterator crend() const { return rend(); } +}; + +template +class Array +{ +public: + T& operator[](size_t aIndex) + { + do { AnnotateMozCrashReason("MOZ_CRASH(" "indexing into zero-length array" ")"); do { *((volatile int*) __null) = 87; ::abort(); } while (0); } while (0); + } + + const T& operator[](size_t aIndex) const + { + do { AnnotateMozCrashReason("MOZ_CRASH(" "indexing into zero-length array" ")"); do { *((volatile int*) __null) = 92; ::abort(); } while (0); } while (0); + } +}; + +} +# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" 2 + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Casting.h" 1 +# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Casting.h" +namespace mozilla { +# 40 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Casting.h" +template +inline void +BitwiseCast(const From aFrom, To* aResult) +{ + static_assert(sizeof(From) == sizeof(To), + "To and From must have the same size"); + union + { + From mFrom; + To mTo; + } u; + u.mFrom = aFrom; + *aResult = u.mTo; +} + +template +inline To +BitwiseCast(const From aFrom) +{ + To temp; + BitwiseCast(aFrom, &temp); + return temp; +} + +namespace detail { + +enum ToSignedness { ToIsSigned, ToIsUnsigned }; +enum FromSignedness { FromIsSigned, FromIsUnsigned }; + +template::value ? FromIsSigned : FromIsUnsigned, + ToSignedness = IsSigned::value ? ToIsSigned : ToIsUnsigned> +struct BoundsCheckImpl; + + + + + + +enum UUComparison { FromIsBigger, FromIsNotBigger }; + + + +template sizeof(To)) + ? FromIsBigger + : FromIsNotBigger> +struct UnsignedUnsignedCheck; + +template +struct UnsignedUnsignedCheck +{ +public: + static bool checkBounds(const From aFrom) + { + return aFrom <= From(To(-1)); + } +}; + +template +struct UnsignedUnsignedCheck +{ +public: + static bool checkBounds(const From aFrom) + { + return true; + } +}; + +template +struct BoundsCheckImpl +{ +public: + static bool checkBounds(const From aFrom) + { + return UnsignedUnsignedCheck::checkBounds(aFrom); + } +}; + + + +template +struct BoundsCheckImpl +{ +public: + static bool checkBounds(const From aFrom) + { + if (aFrom < 0) { + return false; + } + if (sizeof(To) >= sizeof(From)) { + return true; + } + return aFrom <= From(To(-1)); + } +}; + + + +enum USComparison { FromIsSmaller, FromIsNotSmaller }; + +template +struct UnsignedSignedCheck; + +template +struct UnsignedSignedCheck +{ +public: + static bool checkBounds(const From aFrom) + { + return true; + } +}; + +template +struct UnsignedSignedCheck +{ +public: + static bool checkBounds(const From aFrom) + { + const To MaxValue = To((1ULL << (8 * sizeof(To) - 1)) - 1); + return aFrom <= From(MaxValue); + } +}; + +template +struct BoundsCheckImpl +{ +public: + static bool checkBounds(const From aFrom) + { + return UnsignedSignedCheck::checkBounds(aFrom); + } +}; + + + +template +struct BoundsCheckImpl +{ +public: + static bool checkBounds(const From aFrom) + { + if (sizeof(From) <= sizeof(To)) { + return true; + } + const To MaxValue = To((1ULL << (8 * sizeof(To) - 1)) - 1); + const To MinValue = -MaxValue - To(1); + return From(MinValue) <= aFrom && + From(aFrom) <= From(MaxValue); + } +}; + +template::value && + IsIntegral::value> +class BoundsChecker; + +template +class BoundsChecker +{ +public: + static bool checkBounds(const From aFrom) { return true; } +}; + +template +class BoundsChecker +{ +public: + static bool checkBounds(const From aFrom) + { + return BoundsCheckImpl::checkBounds(aFrom); + } +}; + +template +inline bool +IsInBounds(const From aFrom) +{ + return BoundsChecker::checkBounds(aFrom); +} + +} + + + + + + +template +inline To +AssertedCast(const From aFrom) +{ + do { } while (0); + return static_cast(aFrom); +} + + + + + + +template +inline To +ReleaseAssertedCast(const From aFrom) +{ + do { static_assert(mozilla::detail::AssertionConditionType(aFrom)))>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!((detail::IsInBounds(aFrom))))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "(detail::IsInBounds(aFrom))" ")"); do { *((volatile int*) __null) = 250; ::abort(); } while (0); } } while (0); + return static_cast(aFrom); +} + +} +# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" 2 + + + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/algorithm" 1 3 +# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/algorithm" 3 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/utility" 1 3 +# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/utility" 3 +# 69 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/utility" 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_relops.h" 1 3 +# 67 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_relops.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + namespace rel_ops + { +# 85 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_relops.h" 3 + template + inline bool + operator!=(const _Tp& __x, const _Tp& __y) + { return !(__x == __y); } +# 98 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_relops.h" 3 + template + inline bool + operator>(const _Tp& __x, const _Tp& __y) + { return __y < __x; } +# 111 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_relops.h" 3 + template + inline bool + operator<=(const _Tp& __x, const _Tp& __y) + { return !(__y < __x); } +# 124 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_relops.h" 3 + template + inline bool + operator>=(const _Tp& __x, const _Tp& __y) + { return !(__x < __y); } + + + } + +} +# 70 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/utility" 2 3 + + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct tuple_size; + + + + template + struct tuple_size + : integral_constant::value> { }; + + template + struct tuple_size + : integral_constant::value> { }; + + template + struct tuple_size + : integral_constant::value> { }; + + + template + struct tuple_element; + + + template + using __tuple_element_t = typename tuple_element<__i, _Tp>::type; + + template + struct tuple_element<__i, const _Tp> + { + typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type; + }; + + template + struct tuple_element<__i, volatile _Tp> + { + typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type; + }; + + template + struct tuple_element<__i, const volatile _Tp> + { + typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type; + }; + + + + + template + using tuple_element_t = typename tuple_element<__i, _Tp>::type; + + + template + struct __is_tuple_like_impl : false_type + { }; + + + + + template + struct __is_tuple_like_impl> : true_type + { }; + + + template + struct tuple_size> + : public integral_constant { }; + + + template + struct tuple_element<0, std::pair<_Tp1, _Tp2>> + { typedef _Tp1 type; }; + + + template + struct tuple_element<1, std::pair<_Tp1, _Tp2>> + { typedef _Tp2 type; }; + + template + struct __pair_get; + + template<> + struct __pair_get<0> + { + template + static constexpr _Tp1& + __get(std::pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr _Tp1&& + __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp1>(__pair.first); } + + template + static constexpr const _Tp1& + __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + }; + + template<> + struct __pair_get<1> + { + template + static constexpr _Tp2& + __get(std::pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr _Tp2&& + __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp2>(__pair.second); } + + template + static constexpr const _Tp2& + __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + }; + + template + constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type& + get(std::pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__get(__in); } + + template + constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&& + get(std::pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__move_get(std::move(__in)); } + + template + constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type& + get(const std::pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__const_get(__in); } + + + + + + template + constexpr _Tp& + get(pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr const _Tp& + get(const pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr _Tp&& + get(pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr _Tp& + get(pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr const _Tp& + get(const pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr _Tp&& + get(pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } + + + + + template + inline _Tp + exchange(_Tp& __obj, _Up&& __new_val) + { return std::__exchange(__obj, std::forward<_Up>(__new_val)); } + + + + + template struct _Index_tuple { }; + + + template struct _Itup_cat; + + template + struct _Itup_cat<_Index_tuple<_Ind1...>, _Index_tuple<_Ind2...>> + { + using __type = _Index_tuple<_Ind1..., (_Ind2 + sizeof...(_Ind1))...>; + }; + + + template + struct _Build_index_tuple + : _Itup_cat::__type, + typename _Build_index_tuple<_Num - _Num / 2>::__type> + { }; + + template<> + struct _Build_index_tuple<1> + { + typedef _Index_tuple<0> __type; + }; + + template<> + struct _Build_index_tuple<0> + { + typedef _Index_tuple<> __type; + }; + + + + + + + template + struct integer_sequence + { + typedef _Tp value_type; + static constexpr size_t size() { return sizeof...(_Idx); } + }; + + template::__type> + struct _Make_integer_sequence; + + template + struct _Make_integer_sequence<_Tp, _Num, _Index_tuple<_Idx...>> + { + static_assert( _Num >= 0, + "Cannot make integer sequence of negative length" ); + + typedef integer_sequence<_Tp, static_cast<_Tp>(_Idx)...> __type; + }; + + + template + using make_integer_sequence + = typename _Make_integer_sequence<_Tp, _Num>::__type; + + + template + using index_sequence = integer_sequence; + + + template + using make_index_sequence = make_integer_sequence; + + + template + using index_sequence_for = make_index_sequence; + + + +} +# 61 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/algorithm" 2 3 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 1 3 +# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3 +# 60 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/algorithmfwd.h" 1 3 +# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/algorithmfwd.h" 3 + + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 194 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/algorithmfwd.h" 3 + template + bool + all_of(_IIter, _IIter, _Predicate); + + template + bool + any_of(_IIter, _IIter, _Predicate); + + + template + bool + binary_search(_FIter, _FIter, const _Tp&); + + template + bool + binary_search(_FIter, _FIter, const _Tp&, _Compare); + + template + _OIter + copy(_IIter, _IIter, _OIter); + + template + _BIter2 + copy_backward(_BIter1, _BIter1, _BIter2); + + + template + _OIter + copy_if(_IIter, _IIter, _OIter, _Predicate); + + template + _OIter + copy_n(_IIter, _Size, _OIter); + + + + + + template + pair<_FIter, _FIter> + equal_range(_FIter, _FIter, const _Tp&); + + template + pair<_FIter, _FIter> + equal_range(_FIter, _FIter, const _Tp&, _Compare); + + template + void + fill(_FIter, _FIter, const _Tp&); + + template + _OIter + fill_n(_OIter, _Size, const _Tp&); + + + + template + _FIter1 + find_end(_FIter1, _FIter1, _FIter2, _FIter2); + + template + _FIter1 + find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); + + + + + + template + _IIter + find_if_not(_IIter, _IIter, _Predicate); + + + + + + + template + bool + includes(_IIter1, _IIter1, _IIter2, _IIter2); + + template + bool + includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); + + template + void + inplace_merge(_BIter, _BIter, _BIter); + + template + void + inplace_merge(_BIter, _BIter, _BIter, _Compare); + + + template + bool + is_heap(_RAIter, _RAIter); + + template + bool + is_heap(_RAIter, _RAIter, _Compare); + + template + _RAIter + is_heap_until(_RAIter, _RAIter); + + template + _RAIter + is_heap_until(_RAIter, _RAIter, _Compare); + + template + bool + is_partitioned(_IIter, _IIter, _Predicate); + + template + bool + is_permutation(_FIter1, _FIter1, _FIter2); + + template + bool + is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate); + + template + bool + is_sorted(_FIter, _FIter); + + template + bool + is_sorted(_FIter, _FIter, _Compare); + + template + _FIter + is_sorted_until(_FIter, _FIter); + + template + _FIter + is_sorted_until(_FIter, _FIter, _Compare); + + + template + void + iter_swap(_FIter1, _FIter2); + + template + _FIter + lower_bound(_FIter, _FIter, const _Tp&); + + template + _FIter + lower_bound(_FIter, _FIter, const _Tp&, _Compare); + + template + void + make_heap(_RAIter, _RAIter); + + template + void + make_heap(_RAIter, _RAIter, _Compare); + + template + constexpr + const _Tp& + max(const _Tp&, const _Tp&); + + template + constexpr + const _Tp& + max(const _Tp&, const _Tp&, _Compare); + + + + + template + constexpr + const _Tp& + min(const _Tp&, const _Tp&); + + template + constexpr + const _Tp& + min(const _Tp&, const _Tp&, _Compare); + + + + + template + constexpr + pair + minmax(const _Tp&, const _Tp&); + + template + constexpr + pair + minmax(const _Tp&, const _Tp&, _Compare); + + template + constexpr + pair<_FIter, _FIter> + minmax_element(_FIter, _FIter); + + template + constexpr + pair<_FIter, _FIter> + minmax_element(_FIter, _FIter, _Compare); + + template + constexpr + _Tp + min(initializer_list<_Tp>); + + template + constexpr + _Tp + min(initializer_list<_Tp>, _Compare); + + template + constexpr + _Tp + max(initializer_list<_Tp>); + + template + constexpr + _Tp + max(initializer_list<_Tp>, _Compare); + + template + constexpr + pair<_Tp, _Tp> + minmax(initializer_list<_Tp>); + + template + constexpr + pair<_Tp, _Tp> + minmax(initializer_list<_Tp>, _Compare); + + + + + template + bool + next_permutation(_BIter, _BIter); + + template + bool + next_permutation(_BIter, _BIter, _Compare); + + + template + bool + none_of(_IIter, _IIter, _Predicate); + + + + + + template + _RAIter + partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter); + + template + _RAIter + partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare); + + + + + template + pair<_OIter1, _OIter2> + partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate); + + template + _FIter + partition_point(_FIter, _FIter, _Predicate); + + + template + void + pop_heap(_RAIter, _RAIter); + + template + void + pop_heap(_RAIter, _RAIter, _Compare); + + template + bool + prev_permutation(_BIter, _BIter); + + template + bool + prev_permutation(_BIter, _BIter, _Compare); + + template + void + push_heap(_RAIter, _RAIter); + + template + void + push_heap(_RAIter, _RAIter, _Compare); + + + + template + _FIter + remove(_FIter, _FIter, const _Tp&); + + template + _FIter + remove_if(_FIter, _FIter, _Predicate); + + template + _OIter + remove_copy(_IIter, _IIter, _OIter, const _Tp&); + + template + _OIter + remove_copy_if(_IIter, _IIter, _OIter, _Predicate); + + + + template + _OIter + replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&); + + template + _OIter + replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&); + + + + template + void + reverse(_BIter, _BIter); + + template + _OIter + reverse_copy(_BIter, _BIter, _OIter); + + inline namespace _V2 + { + template + _FIter + rotate(_FIter, _FIter, _FIter); + } + + template + _OIter + rotate_copy(_FIter, _FIter, _FIter, _OIter); +# 552 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/algorithmfwd.h" 3 + template + void + shuffle(_RAIter, _RAIter, _UGenerator&&); + + + template + void + sort_heap(_RAIter, _RAIter); + + template + void + sort_heap(_RAIter, _RAIter, _Compare); + + template + _BIter + stable_partition(_BIter, _BIter, _Predicate); +# 581 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/algorithmfwd.h" 3 + template + _FIter2 + swap_ranges(_FIter1, _FIter1, _FIter2); + + + + template + _FIter + unique(_FIter, _FIter); + + template + _FIter + unique(_FIter, _FIter, _BinaryPredicate); + + + + template + _FIter + upper_bound(_FIter, _FIter, const _Tp&); + + template + _FIter + upper_bound(_FIter, _FIter, const _Tp&, _Compare); + + + + + + template + _FIter + adjacent_find(_FIter, _FIter); + + template + _FIter + adjacent_find(_FIter, _FIter, _BinaryPredicate); + + template + typename iterator_traits<_IIter>::difference_type + count(_IIter, _IIter, const _Tp&); + + template + typename iterator_traits<_IIter>::difference_type + count_if(_IIter, _IIter, _Predicate); + + template + bool + equal(_IIter1, _IIter1, _IIter2); + + template + bool + equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate); + + template + _IIter + find(_IIter, _IIter, const _Tp&); + + template + _FIter1 + find_first_of(_FIter1, _FIter1, _FIter2, _FIter2); + + template + _FIter1 + find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); + + template + _IIter + find_if(_IIter, _IIter, _Predicate); + + template + _Funct + for_each(_IIter, _IIter, _Funct); + + template + void + generate(_FIter, _FIter, _Generator); + + template + _OIter + generate_n(_OIter, _Size, _Generator); + + template + bool + lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2); + + template + bool + lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); + + template + constexpr + _FIter + max_element(_FIter, _FIter); + + template + constexpr + _FIter + max_element(_FIter, _FIter, _Compare); + + template + _OIter + merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + _OIter + merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + constexpr + _FIter + min_element(_FIter, _FIter); + + template + constexpr + _FIter + min_element(_FIter, _FIter, _Compare); + + template + pair<_IIter1, _IIter2> + mismatch(_IIter1, _IIter1, _IIter2); + + template + pair<_IIter1, _IIter2> + mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate); + + template + void + nth_element(_RAIter, _RAIter, _RAIter); + + template + void + nth_element(_RAIter, _RAIter, _RAIter, _Compare); + + template + void + partial_sort(_RAIter, _RAIter, _RAIter); + + template + void + partial_sort(_RAIter, _RAIter, _RAIter, _Compare); + + template + _BIter + partition(_BIter, _BIter, _Predicate); + + template + void + random_shuffle(_RAIter, _RAIter); + + template + void + random_shuffle(_RAIter, _RAIter, + + _Generator&&); + + + + + template + void + replace(_FIter, _FIter, const _Tp&, const _Tp&); + + template + void + replace_if(_FIter, _FIter, _Predicate, const _Tp&); + + template + _FIter1 + search(_FIter1, _FIter1, _FIter2, _FIter2); + + template + _FIter1 + search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); + + template + _FIter + search_n(_FIter, _FIter, _Size, const _Tp&); + + template + _FIter + search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate); + + template + _OIter + set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + _OIter + set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + _OIter + set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + _OIter + set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + _OIter + set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + _OIter + set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, + _OIter, _Compare); + + template + _OIter + set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + _OIter + set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + void + sort(_RAIter, _RAIter); + + template + void + sort(_RAIter, _RAIter, _Compare); + + template + void + stable_sort(_RAIter, _RAIter); + + template + void + stable_sort(_RAIter, _RAIter, _Compare); + + template + _OIter + transform(_IIter, _IIter, _OIter, _UnaryOperation); + + template + _OIter + transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation); + + template + _OIter + unique_copy(_IIter, _IIter, _OIter); + + template + _OIter + unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate); + + +} +# 61 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 1 3 +# 62 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + _Distance + __is_heap_until(_RandomAccessIterator __first, _Distance __n, + _Compare __comp) + { + _Distance __parent = 0; + for (_Distance __child = 1; __child < __n; ++__child) + { + if (__comp(__first + __parent, __first + __child)) + return __child; + if ((__child & 1) == 0) + ++__parent; + } + return __n; + } + + + + template + inline bool + __is_heap(_RandomAccessIterator __first, _Distance __n) + { + return std::__is_heap_until(__first, __n, + __gnu_cxx::__ops::__iter_less_iter()) == __n; + } + + template + inline bool + __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n) + { + return std::__is_heap_until(__first, __n, + __gnu_cxx::__ops::__iter_comp_iter(__comp)) == __n; + } + + template + inline bool + __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { return std::__is_heap(__first, std::distance(__first, __last)); } + + template + inline bool + __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { return std::__is_heap(__first, __comp, std::distance(__first, __last)); } + + + + + template + void + __push_heap(_RandomAccessIterator __first, + _Distance __holeIndex, _Distance __topIndex, _Tp __value, + _Compare __comp) + { + _Distance __parent = (__holeIndex - 1) / 2; + while (__holeIndex > __topIndex && __comp(__first + __parent, __value)) + { + *(__first + __holeIndex) = std::move(*(__first + __parent)); + __holeIndex = __parent; + __parent = (__holeIndex - 1) / 2; + } + *(__first + __holeIndex) = std::move(__value); + } +# 148 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3 + template + inline void + push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + + + + + ; + ; + ; + + _ValueType __value = std::move(*(__last - 1)); + std::__push_heap(__first, _DistanceType((__last - __first) - 1), + _DistanceType(0), std::move(__value), + __gnu_cxx::__ops::__iter_less_val()); + } +# 183 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3 + template + inline void + push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + + + + ; + ; + ; + + _ValueType __value = std::move(*(__last - 1)); + std::__push_heap(__first, _DistanceType((__last - __first) - 1), + _DistanceType(0), std::move(__value), + __gnu_cxx::__ops::__iter_comp_val(__comp)); + } + + template + void + __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex, + _Distance __len, _Tp __value, _Compare __comp) + { + const _Distance __topIndex = __holeIndex; + _Distance __secondChild = __holeIndex; + while (__secondChild < (__len - 1) / 2) + { + __secondChild = 2 * (__secondChild + 1); + if (__comp(__first + __secondChild, + __first + (__secondChild - 1))) + __secondChild--; + *(__first + __holeIndex) = std::move(*(__first + __secondChild)); + __holeIndex = __secondChild; + } + if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2) + { + __secondChild = 2 * (__secondChild + 1); + *(__first + __holeIndex) = std::move(*(__first + (__secondChild - 1))); + + __holeIndex = __secondChild - 1; + } + std::__push_heap(__first, __holeIndex, __topIndex, + std::move(__value), + __gnu_cxx::__ops::__iter_comp_val(__comp)); + } + + template + inline void + __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _RandomAccessIterator __result, _Compare __comp) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + _ValueType __value = std::move(*__result); + *__result = std::move(*__first); + std::__adjust_heap(__first, _DistanceType(0), + _DistanceType(__last - __first), + std::move(__value), __comp); + } +# 263 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3 + template + inline void + pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + + + + + + ; + ; + ; + ; + + if (__last - __first > 1) + { + --__last; + std::__pop_heap(__first, __last, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } + } +# 296 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3 + template + inline void + pop_heap(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + + + + ; + ; + ; + ; + + if (__last - __first > 1) + { + --__last; + std::__pop_heap(__first, __last, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + } + + template + void + __make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + if (__last - __first < 2) + return; + + const _DistanceType __len = __last - __first; + _DistanceType __parent = (__len - 2) / 2; + while (true) + { + _ValueType __value = std::move(*(__first + __parent)); + std::__adjust_heap(__first, __parent, __len, std::move(__value), + __comp); + if (__parent == 0) + return; + __parent--; + } + } +# 351 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3 + template + inline void + make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + + + + + + ; + ; + + std::__make_heap(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 377 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3 + template + inline void + make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + + + + ; + ; + + std::__make_heap(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + void + __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + while (__last - __first > 1) + { + --__last; + std::__pop_heap(__first, __last, __last, __comp); + } + } +# 412 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3 + template + inline void + sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + + + + + + ; + ; + ; + + std::__sort_heap(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 439 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3 + template + inline void + sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + + + + ; + ; + ; + + std::__sort_heap(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 466 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3 + template + inline _RandomAccessIterator + is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + + + + + + ; + ; + + return __first + + std::__is_heap_until(__first, std::distance(__first, __last), + __gnu_cxx::__ops::__iter_less_iter()); + } +# 494 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3 + template + inline _RandomAccessIterator + is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + + + + ; + ; + + return __first + + std::__is_heap_until(__first, std::distance(__first, __last), + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 517 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3 + template + inline bool + is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { return std::is_heap_until(__first, __last) == __last; } +# 530 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3 + template + inline bool + is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { return std::is_heap_until(__first, __last, __comp) == __last; } + + + +} +# 62 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_tempbuf.h" 1 3 +# 60 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_tempbuf.h" 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_construct.h" 1 3 +# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_construct.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + inline void + _Construct(_T1* __p, _Args&&... __args) + { ::new(static_cast(__p)) _T1(std::forward<_Args>(__args)...); } +# 90 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_construct.h" 3 + template + inline void + _Destroy(_Tp* __pointer) + { __pointer->~_Tp(); } + + template + struct _Destroy_aux + { + template + static void + __destroy(_ForwardIterator __first, _ForwardIterator __last) + { + for (; __first != __last; ++__first) + std::_Destroy(std::__addressof(*__first)); + } + }; + + template<> + struct _Destroy_aux + { + template + static void + __destroy(_ForwardIterator, _ForwardIterator) { } + }; + + + + + + + template + inline void + _Destroy(_ForwardIterator __first, _ForwardIterator __last) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _Value_type; + std::_Destroy_aux<__has_trivial_destructor(_Value_type)>:: + __destroy(__first, __last); + } + + + + + + + + template + void + _Destroy(_ForwardIterator __first, _ForwardIterator __last, + _Allocator& __alloc) + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __first != __last; ++__first) + __traits::destroy(__alloc, std::__addressof(*__first)); + } + + template + inline void + _Destroy(_ForwardIterator __first, _ForwardIterator __last, + allocator<_Tp>&) + { + _Destroy(__first, __last); + } + + +} +# 61 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_tempbuf.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 83 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_tempbuf.h" 3 + template + pair<_Tp*, ptrdiff_t> + get_temporary_buffer(ptrdiff_t __len) noexcept + { + const ptrdiff_t __max = + __gnu_cxx::__numeric_traits::__max / sizeof(_Tp); + if (__len > __max) + __len = __max; + + while (__len > 0) + { + _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp), + std::nothrow)); + if (__tmp != 0) + return std::pair<_Tp*, ptrdiff_t>(__tmp, __len); + __len /= 2; + } + return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0); + } +# 110 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_tempbuf.h" 3 + template + inline void + return_temporary_buffer(_Tp* __p) + { ::operator delete(__p, std::nothrow); } + + + + + + + + template + class _Temporary_buffer + { + + + + public: + typedef _Tp value_type; + typedef value_type* pointer; + typedef pointer iterator; + typedef ptrdiff_t size_type; + + protected: + size_type _M_original_len; + size_type _M_len; + pointer _M_buffer; + + public: + + size_type + size() const + { return _M_len; } + + + size_type + requested_size() const + { return _M_original_len; } + + + iterator + begin() + { return _M_buffer; } + + + iterator + end() + { return _M_buffer + _M_len; } + + + + + + _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last); + + ~_Temporary_buffer() + { + std::_Destroy(_M_buffer, _M_buffer + _M_len); + std::return_temporary_buffer(_M_buffer); + } + + private: + + _Temporary_buffer(const _Temporary_buffer&); + + void + operator=(const _Temporary_buffer&); + }; + + + template + struct __uninitialized_construct_buf_dispatch + { + template + static void + __ucr(_Pointer __first, _Pointer __last, + _ForwardIterator __seed) + { + if(__first == __last) + return; + + _Pointer __cur = __first; + try + { + std::_Construct(std::__addressof(*__first), + std::move(*__seed)); + _Pointer __prev = __cur; + ++__cur; + for(; __cur != __last; ++__cur, ++__prev) + std::_Construct(std::__addressof(*__cur), + std::move(*__prev)); + *__seed = std::move(*__prev); + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + }; + + template<> + struct __uninitialized_construct_buf_dispatch + { + template + static void + __ucr(_Pointer, _Pointer, _ForwardIterator) { } + }; +# 229 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_tempbuf.h" 3 + template + inline void + __uninitialized_construct_buf(_Pointer __first, _Pointer __last, + _ForwardIterator __seed) + { + typedef typename std::iterator_traits<_Pointer>::value_type + _ValueType; + + std::__uninitialized_construct_buf_dispatch< + __has_trivial_constructor(_ValueType)>:: + __ucr(__first, __last, __seed); + } + + template + _Temporary_buffer<_ForwardIterator, _Tp>:: + _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last) + : _M_original_len(std::distance(__first, __last)), + _M_len(0), _M_buffer(0) + { + try + { + std::pair __p(std::get_temporary_buffer< + value_type>(_M_original_len)); + _M_buffer = __p.first; + _M_len = __p.second; + if (_M_buffer) + std::__uninitialized_construct_buf(_M_buffer, _M_buffer + _M_len, + __first); + } + catch(...) + { + std::return_temporary_buffer(_M_buffer); + _M_buffer = 0; + _M_len = 0; + throw; + } + } + + +} +# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 2 3 + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uniform_int_dist.h" 1 3 +# 35 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uniform_int_dist.h" 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 1 3 +# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 3 +# 158 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + enum float_round_style + { + round_indeterminate = -1, + round_toward_zero = 0, + round_to_nearest = 1, + round_toward_infinity = 2, + round_toward_neg_infinity = 3 + }; + + + + + + + + enum float_denorm_style + { + + denorm_indeterminate = -1, + + denorm_absent = 0, + + denorm_present = 1 + }; +# 202 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 3 + struct __numeric_limits_base + { + + + static constexpr bool is_specialized = false; + + + + + static constexpr int digits = 0; + + + static constexpr int digits10 = 0; + + + + + static constexpr int max_digits10 = 0; + + + + static constexpr bool is_signed = false; + + + static constexpr bool is_integer = false; + + + + + static constexpr bool is_exact = false; + + + + static constexpr int radix = 0; + + + + static constexpr int min_exponent = 0; + + + + static constexpr int min_exponent10 = 0; + + + + + static constexpr int max_exponent = 0; + + + + static constexpr int max_exponent10 = 0; + + + static constexpr bool has_infinity = false; + + + + static constexpr bool has_quiet_NaN = false; + + + + static constexpr bool has_signaling_NaN = false; + + + static constexpr float_denorm_style has_denorm = denorm_absent; + + + + static constexpr bool has_denorm_loss = false; + + + + static constexpr bool is_iec559 = false; + + + + + static constexpr bool is_bounded = false; +# 288 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 3 + static constexpr bool is_modulo = false; + + + static constexpr bool traps = false; + + + static constexpr bool tinyness_before = false; + + + + + static constexpr float_round_style round_style = + round_toward_zero; + }; +# 314 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 3 + template + struct numeric_limits : public __numeric_limits_base + { + + + static constexpr _Tp + min() noexcept { return _Tp(); } + + + static constexpr _Tp + max() noexcept { return _Tp(); } + + + + + static constexpr _Tp + lowest() noexcept { return _Tp(); } + + + + + static constexpr _Tp + epsilon() noexcept { return _Tp(); } + + + static constexpr _Tp + round_error() noexcept { return _Tp(); } + + + static constexpr _Tp + infinity() noexcept { return _Tp(); } + + + + static constexpr _Tp + quiet_NaN() noexcept { return _Tp(); } + + + + static constexpr _Tp + signaling_NaN() noexcept { return _Tp(); } + + + + + static constexpr _Tp + denorm_min() noexcept { return _Tp(); } + }; + + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; + + + + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr bool + min() noexcept { return false; } + + static constexpr bool + max() noexcept { return true; } + + + static constexpr bool + lowest() noexcept { return min(); } + + static constexpr int digits = 1; + static constexpr int digits10 = 0; + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr bool + epsilon() noexcept { return false; } + + static constexpr bool + round_error() noexcept { return false; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr bool + infinity() noexcept { return false; } + + static constexpr bool + quiet_NaN() noexcept { return false; } + + static constexpr bool + signaling_NaN() noexcept { return false; } + + static constexpr bool + denorm_min() noexcept { return false; } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + + + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char + min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); } + + static constexpr char + max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); } + + + static constexpr char + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = ((char)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char + epsilon() noexcept { return 0; } + + static constexpr char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr + char infinity() noexcept { return char(); } + + static constexpr char + quiet_NaN() noexcept { return char(); } + + static constexpr char + signaling_NaN() noexcept { return char(); } + + static constexpr char + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr signed char + min() noexcept { return -127 - 1; } + + static constexpr signed char + max() noexcept { return 127; } + + + static constexpr signed char + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr signed char + epsilon() noexcept { return 0; } + + static constexpr signed char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr signed char + infinity() noexcept { return static_cast(0); } + + static constexpr signed char + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr signed char + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr signed char + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned char + min() noexcept { return 0; } + + static constexpr unsigned char + max() noexcept { return 127 * 2U + 1; } + + + static constexpr unsigned char + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned char + epsilon() noexcept { return 0; } + + static constexpr unsigned char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned char + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned char + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned char + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned char + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr wchar_t + min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); } + + static constexpr wchar_t + max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); } + + + static constexpr wchar_t + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = ((wchar_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr wchar_t + epsilon() noexcept { return 0; } + + static constexpr wchar_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr wchar_t + infinity() noexcept { return wchar_t(); } + + static constexpr wchar_t + quiet_NaN() noexcept { return wchar_t(); } + + static constexpr wchar_t + signaling_NaN() noexcept { return wchar_t(); } + + static constexpr wchar_t + denorm_min() noexcept { return wchar_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char16_t + min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); } + + static constexpr char16_t + max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); } + + static constexpr char16_t + lowest() noexcept { return min(); } + + static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136); + static constexpr int max_digits10 = 0; + static constexpr bool is_signed = ((char16_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char16_t + epsilon() noexcept { return 0; } + + static constexpr char16_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr char16_t + infinity() noexcept { return char16_t(); } + + static constexpr char16_t + quiet_NaN() noexcept { return char16_t(); } + + static constexpr char16_t + signaling_NaN() noexcept { return char16_t(); } + + static constexpr char16_t + denorm_min() noexcept { return char16_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char32_t + min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); } + + static constexpr char32_t + max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); } + + static constexpr char32_t + lowest() noexcept { return min(); } + + static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136); + static constexpr int max_digits10 = 0; + static constexpr bool is_signed = ((char32_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char32_t + epsilon() noexcept { return 0; } + + static constexpr char32_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr char32_t + infinity() noexcept { return char32_t(); } + + static constexpr char32_t + quiet_NaN() noexcept { return char32_t(); } + + static constexpr char32_t + signaling_NaN() noexcept { return char32_t(); } + + static constexpr char32_t + denorm_min() noexcept { return char32_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style = round_toward_zero; + }; + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr short + min() noexcept { return -32767 - 1; } + + static constexpr short + max() noexcept { return 32767; } + + + static constexpr short + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0)); + static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr short + epsilon() noexcept { return 0; } + + static constexpr short + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr short + infinity() noexcept { return short(); } + + static constexpr short + quiet_NaN() noexcept { return short(); } + + static constexpr short + signaling_NaN() noexcept { return short(); } + + static constexpr short + denorm_min() noexcept { return short(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned short + min() noexcept { return 0; } + + static constexpr unsigned short + max() noexcept { return 32767 * 2U + 1; } + + + static constexpr unsigned short + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned short + epsilon() noexcept { return 0; } + + static constexpr unsigned short + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned short + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned short + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned short + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned short + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr int + min() noexcept { return -2147483647 - 1; } + + static constexpr int + max() noexcept { return 2147483647; } + + + static constexpr int + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0)); + static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr int + epsilon() noexcept { return 0; } + + static constexpr int + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr int + infinity() noexcept { return static_cast(0); } + + static constexpr int + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr int + signaling_NaN() noexcept { return static_cast(0); } + + static constexpr int + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned int + min() noexcept { return 0; } + + static constexpr unsigned int + max() noexcept { return 2147483647 * 2U + 1; } + + + static constexpr unsigned int + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned int + epsilon() noexcept { return 0; } + + static constexpr unsigned int + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned int + infinity() noexcept { return static_cast(0); } + + static constexpr unsigned int + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned int + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned int + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr long + min() noexcept { return -9223372036854775807L - 1; } + + static constexpr long + max() noexcept { return 9223372036854775807L; } + + + static constexpr long + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0)); + static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr long + epsilon() noexcept { return 0; } + + static constexpr long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr long + infinity() noexcept { return static_cast(0); } + + static constexpr long + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr long + signaling_NaN() noexcept { return static_cast(0); } + + static constexpr long + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned long + min() noexcept { return 0; } + + static constexpr unsigned long + max() noexcept { return 9223372036854775807L * 2UL + 1; } + + + static constexpr unsigned long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned long + epsilon() noexcept { return 0; } + + static constexpr unsigned long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned long + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned long + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr long long + min() noexcept { return -9223372036854775807LL - 1; } + + static constexpr long long + max() noexcept { return 9223372036854775807LL; } + + + static constexpr long long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(long long) * 8 - ((long long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr long long + epsilon() noexcept { return 0; } + + static constexpr long long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr long long + infinity() noexcept { return static_cast(0); } + + static constexpr long long + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr long long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr long long + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned long long + min() noexcept { return 0; } + + static constexpr unsigned long long + max() noexcept { return 9223372036854775807LL * 2ULL + 1; } + + + static constexpr unsigned long long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned long long + epsilon() noexcept { return 0; } + + static constexpr unsigned long long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned long long + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; +# 1592 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr float + min() noexcept { return 1.17549435e-38F; } + + static constexpr float + max() noexcept { return 3.40282347e+38F; } + + + static constexpr float + lowest() noexcept { return -3.40282347e+38F; } + + + static constexpr int digits = 24; + static constexpr int digits10 = 6; + + static constexpr int max_digits10 + = (2 + (24) * 643L / 2136); + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr float + epsilon() noexcept { return 1.19209290e-7F; } + + static constexpr float + round_error() noexcept { return 0.5F; } + + static constexpr int min_exponent = (-125); + static constexpr int min_exponent10 = (-37); + static constexpr int max_exponent = 128; + static constexpr int max_exponent10 = 38; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + static constexpr bool has_signaling_NaN = has_quiet_NaN; + static constexpr float_denorm_style has_denorm + = bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + = false; + + static constexpr float + infinity() noexcept { return __builtin_huge_valf(); } + + static constexpr float + quiet_NaN() noexcept { return __builtin_nanf(""); } + + static constexpr float + signaling_NaN() noexcept { return __builtin_nansf(""); } + + static constexpr float + denorm_min() noexcept { return 1.40129846e-45F; } + + static constexpr bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before + = false; + static constexpr float_round_style round_style + = round_to_nearest; + }; + + + + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr double + min() noexcept { return 2.2250738585072014e-308; } + + static constexpr double + max() noexcept { return 1.7976931348623157e+308; } + + + static constexpr double + lowest() noexcept { return -1.7976931348623157e+308; } + + + static constexpr int digits = 53; + static constexpr int digits10 = 15; + + static constexpr int max_digits10 + = (2 + (53) * 643L / 2136); + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr double + epsilon() noexcept { return 2.2204460492503131e-16; } + + static constexpr double + round_error() noexcept { return 0.5; } + + static constexpr int min_exponent = (-1021); + static constexpr int min_exponent10 = (-307); + static constexpr int max_exponent = 1024; + static constexpr int max_exponent10 = 308; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + static constexpr bool has_signaling_NaN = has_quiet_NaN; + static constexpr float_denorm_style has_denorm + = bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + = false; + + static constexpr double + infinity() noexcept { return __builtin_huge_val(); } + + static constexpr double + quiet_NaN() noexcept { return __builtin_nan(""); } + + static constexpr double + signaling_NaN() noexcept { return __builtin_nans(""); } + + static constexpr double + denorm_min() noexcept { return 4.9406564584124654e-324; } + + static constexpr bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before + = false; + static constexpr float_round_style round_style + = round_to_nearest; + }; + + + + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr long double + min() noexcept { return 3.36210314311209350626e-4932L; } + + static constexpr long double + max() noexcept { return 1.18973149535723176502e+4932L; } + + + static constexpr long double + lowest() noexcept { return -1.18973149535723176502e+4932L; } + + + static constexpr int digits = 64; + static constexpr int digits10 = 18; + + static constexpr int max_digits10 + = (2 + (64) * 643L / 2136); + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr long double + epsilon() noexcept { return 1.08420217248550443401e-19L; } + + static constexpr long double + round_error() noexcept { return 0.5L; } + + static constexpr int min_exponent = (-16381); + static constexpr int min_exponent10 = (-4931); + static constexpr int max_exponent = 16384; + static constexpr int max_exponent10 = 4932; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + static constexpr bool has_signaling_NaN = has_quiet_NaN; + static constexpr float_denorm_style has_denorm + = bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + = false; + + static constexpr long double + infinity() noexcept { return __builtin_huge_vall(); } + + static constexpr long double + quiet_NaN() noexcept { return __builtin_nanl(""); } + + static constexpr long double + signaling_NaN() noexcept { return __builtin_nansl(""); } + + static constexpr long double + denorm_min() noexcept { return 3.64519953188247460253e-4951L; } + + static constexpr bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before = + false; + static constexpr float_round_style round_style = + round_to_nearest; + }; + + + + + + +} +# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uniform_int_dist.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + namespace __detail + { + + + template + inline bool + _Power_of_2(_Tp __x) + { + return ((__x - 1) & __x) == 0; + }; + + } +# 60 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uniform_int_dist.h" 3 + template + class uniform_int_distribution + { + static_assert(std::is_integral<_IntType>::value, + "template argument not an integral type"); + + public: + + typedef _IntType result_type; + + struct param_type + { + typedef uniform_int_distribution<_IntType> distribution_type; + + explicit + param_type(_IntType __a = 0, + _IntType __b = std::numeric_limits<_IntType>::max()) + : _M_a(__a), _M_b(__b) + { + ; + } + + result_type + a() const + { return _M_a; } + + result_type + b() const + { return _M_b; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } + + private: + _IntType _M_a; + _IntType _M_b; + }; + + public: + + + + explicit + uniform_int_distribution(_IntType __a = 0, + _IntType __b = std::numeric_limits<_IntType>::max()) + : _M_param(__a, __b) + { } + + explicit + uniform_int_distribution(const param_type& __p) + : _M_param(__p) + { } + + + + + + + void + reset() { } + + result_type + a() const + { return _M_param.a(); } + + result_type + b() const + { return _M_param.b(); } + + + + + param_type + param() const + { return _M_param; } + + + + + + void + param(const param_type& __param) + { _M_param = __param; } + + + + + result_type + min() const + { return this->a(); } + + + + + result_type + max() const + { return this->b(); } + + + + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng) + { return this->operator()(__urng, _M_param); } + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p); + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate(__f, __t, __urng, _M_param); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + + + + + friend bool + operator==(const uniform_int_distribution& __d1, + const uniform_int_distribution& __d2) + { return __d1._M_param == __d2._M_param; } + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p); + + param_type _M_param; + }; + + template + template + typename uniform_int_distribution<_IntType>::result_type + uniform_int_distribution<_IntType>:: + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __param) + { + typedef typename _UniformRandomNumberGenerator::result_type + _Gresult_type; + typedef typename std::make_unsigned::type __utype; + typedef typename std::common_type<_Gresult_type, __utype>::type + __uctype; + + const __uctype __urngmin = __urng.min(); + const __uctype __urngmax = __urng.max(); + const __uctype __urngrange = __urngmax - __urngmin; + const __uctype __urange + = __uctype(__param.b()) - __uctype(__param.a()); + + __uctype __ret; + + if (__urngrange > __urange) + { + + const __uctype __uerange = __urange + 1; + const __uctype __scaling = __urngrange / __uerange; + const __uctype __past = __uerange * __scaling; + do + __ret = __uctype(__urng()) - __urngmin; + while (__ret >= __past); + __ret /= __scaling; + } + else if (__urngrange < __urange) + { +# 263 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uniform_int_dist.h" 3 + __uctype __tmp; + do + { + const __uctype __uerngrange = __urngrange + 1; + __tmp = (__uerngrange * operator() + (__urng, param_type(0, __urange / __uerngrange))); + __ret = __tmp + (__uctype(__urng()) - __urngmin); + } + while (__ret > __urange || __ret < __tmp); + } + else + __ret = __uctype(__urng()) - __urngmin; + + return __ret + __param.a(); + } + + + template + template + void + uniform_int_distribution<_IntType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __param) + { + + typedef typename _UniformRandomNumberGenerator::result_type + _Gresult_type; + typedef typename std::make_unsigned::type __utype; + typedef typename std::common_type<_Gresult_type, __utype>::type + __uctype; + + const __uctype __urngmin = __urng.min(); + const __uctype __urngmax = __urng.max(); + const __uctype __urngrange = __urngmax - __urngmin; + const __uctype __urange + = __uctype(__param.b()) - __uctype(__param.a()); + + __uctype __ret; + + if (__urngrange > __urange) + { + if (__detail::_Power_of_2(__urngrange + 1) + && __detail::_Power_of_2(__urange + 1)) + { + while (__f != __t) + { + __ret = __uctype(__urng()) - __urngmin; + *__f++ = (__ret & __urange) + __param.a(); + } + } + else + { + + const __uctype __uerange = __urange + 1; + const __uctype __scaling = __urngrange / __uerange; + const __uctype __past = __uerange * __scaling; + while (__f != __t) + { + do + __ret = __uctype(__urng()) - __urngmin; + while (__ret >= __past); + *__f++ = __ret / __scaling + __param.a(); + } + } + } + else if (__urngrange < __urange) + { +# 347 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uniform_int_dist.h" 3 + __uctype __tmp; + while (__f != __t) + { + do + { + const __uctype __uerngrange = __urngrange + 1; + __tmp = (__uerngrange * operator() + (__urng, param_type(0, __urange / __uerngrange))); + __ret = __tmp + (__uctype(__urng()) - __urngmin); + } + while (__ret > __urange || __ret < __tmp); + *__f++ = __ret; + } + } + else + while (__f != __t) + *__f++ = __uctype(__urng()) - __urngmin + __param.a(); + } + + +} +# 67 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 2 3 + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + void + __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b, + _Iterator __c, _Compare __comp) + { + if (__comp(__a, __b)) + { + if (__comp(__b, __c)) + std::iter_swap(__result, __b); + else if (__comp(__a, __c)) + std::iter_swap(__result, __c); + else + std::iter_swap(__result, __a); + } + else if (__comp(__a, __c)) + std::iter_swap(__result, __a); + else if (__comp(__b, __c)) + std::iter_swap(__result, __c); + else + std::iter_swap(__result, __b); + } + + + template + inline _InputIterator + __find_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred, input_iterator_tag) + { + while (__first != __last && !__pred(__first)) + ++__first; + return __first; + } + + + template + _RandomAccessIterator + __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Predicate __pred, random_access_iterator_tag) + { + typename iterator_traits<_RandomAccessIterator>::difference_type + __trip_count = (__last - __first) >> 2; + + for (; __trip_count > 0; --__trip_count) + { + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + } + + switch (__last - __first) + { + case 3: + if (__pred(__first)) + return __first; + ++__first; + case 2: + if (__pred(__first)) + return __first; + ++__first; + case 1: + if (__pred(__first)) + return __first; + ++__first; + case 0: + default: + return __last; + } + } + + template + inline _Iterator + __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) + { + return __find_if(__first, __last, __pred, + std::__iterator_category(__first)); + } + + + template + inline _InputIterator + __find_if_not(_InputIterator __first, _InputIterator __last, + _Predicate __pred) + { + return std::__find_if(__first, __last, + __gnu_cxx::__ops::__negate(__pred), + std::__iterator_category(__first)); + } + + + + + template + _InputIterator + __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred) + { + for (; __len; --__len, ++__first) + if (!__pred(__first)) + break; + return __first; + } +# 202 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + _ForwardIterator1 + __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __predicate) + { + + if (__first1 == __last1 || __first2 == __last2) + return __first1; + + + _ForwardIterator2 __p1(__first2); + if (++__p1 == __last2) + return std::__find_if(__first1, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); + + + _ForwardIterator2 __p; + _ForwardIterator1 __current = __first1; + + for (;;) + { + __first1 = + std::__find_if(__first1, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); + + if (__first1 == __last1) + return __last1; + + __p = __p1; + __current = __first1; + if (++__current == __last1) + return __last1; + + while (__predicate(__current, __p)) + { + if (++__p == __last2) + return __first1; + if (++__current == __last1) + return __last1; + } + ++__first1; + } + return __first1; + } + + + + + + + template + _ForwardIterator + __search_n_aux(_ForwardIterator __first, _ForwardIterator __last, + _Integer __count, _UnaryPredicate __unary_pred, + std::forward_iterator_tag) + { + __first = std::__find_if(__first, __last, __unary_pred); + while (__first != __last) + { + typename iterator_traits<_ForwardIterator>::difference_type + __n = __count; + _ForwardIterator __i = __first; + ++__i; + while (__i != __last && __n != 1 && __unary_pred(__i)) + { + ++__i; + --__n; + } + if (__n == 1) + return __first; + if (__i == __last) + return __last; + __first = std::__find_if(++__i, __last, __unary_pred); + } + return __last; + } + + + + + + template + _RandomAccessIter + __search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last, + _Integer __count, _UnaryPredicate __unary_pred, + std::random_access_iterator_tag) + { + typedef typename std::iterator_traits<_RandomAccessIter>::difference_type + _DistanceType; + + _DistanceType __tailSize = __last - __first; + _DistanceType __remainder = __count; + + while (__remainder <= __tailSize) + { + __first += __remainder; + __tailSize -= __remainder; + + + _RandomAccessIter __backTrack = __first; + while (__unary_pred(--__backTrack)) + { + if (--__remainder == 0) + return (__first - __count); + } + __remainder = __count + 1 - (__first - __backTrack); + } + return __last; + } + + template + _ForwardIterator + __search_n(_ForwardIterator __first, _ForwardIterator __last, + _Integer __count, + _UnaryPredicate __unary_pred) + { + if (__count <= 0) + return __first; + + if (__count == 1) + return std::__find_if(__first, __last, __unary_pred); + + return std::__search_n_aux(__first, __last, __count, __unary_pred, + std::__iterator_category(__first)); + } + + + template + _ForwardIterator1 + __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + forward_iterator_tag, forward_iterator_tag, + _BinaryPredicate __comp) + { + if (__first2 == __last2) + return __last1; + + _ForwardIterator1 __result = __last1; + while (1) + { + _ForwardIterator1 __new_result + = std::__search(__first1, __last1, __first2, __last2, __comp); + if (__new_result == __last1) + return __result; + else + { + __result = __new_result; + __first1 = __new_result; + ++__first1; + } + } + } + + + template + _BidirectionalIterator1 + __find_end(_BidirectionalIterator1 __first1, + _BidirectionalIterator1 __last1, + _BidirectionalIterator2 __first2, + _BidirectionalIterator2 __last2, + bidirectional_iterator_tag, bidirectional_iterator_tag, + _BinaryPredicate __comp) + { + + + + + + + typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1; + typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2; + + _RevIterator1 __rlast1(__first1); + _RevIterator2 __rlast2(__first2); + _RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1, + _RevIterator2(__last2), __rlast2, + __comp); + + if (__rresult == __rlast1) + return __last1; + else + { + _BidirectionalIterator1 __result = __rresult.base(); + std::advance(__result, -std::distance(__first2, __last2)); + return __result; + } + } +# 423 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _ForwardIterator1 + find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2) + { + + + + + + + ; + ; + + return std::__find_end(__first1, __last1, __first2, __last2, + std::__iterator_category(__first1), + std::__iterator_category(__first2), + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 471 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _ForwardIterator1 + find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __comp) + { + + + + + + + ; + ; + + return std::__find_end(__first1, __last1, __first2, __last2, + std::__iterator_category(__first1), + std::__iterator_category(__first2), + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 506 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline bool + all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { return __last == std::find_if_not(__first, __last, __pred); } +# 523 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline bool + none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { return __last == std::find_if(__first, __last, __pred); } +# 541 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline bool + any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { return !std::none_of(__first, __last, __pred); } +# 556 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _InputIterator + find_if_not(_InputIterator __first, _InputIterator __last, + _Predicate __pred) + { + + + + + ; + return std::__find_if_not(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } +# 580 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline bool + is_partitioned(_InputIterator __first, _InputIterator __last, + _Predicate __pred) + { + __first = std::find_if_not(__first, __last, __pred); + return std::none_of(__first, __last, __pred); + } +# 598 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + _ForwardIterator + partition_point(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + + + + + + + ; + + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len = std::distance(__first, __last); + _DistanceType __half; + _ForwardIterator __middle; + + while (__len > 0) + { + __half = __len >> 1; + __middle = __first; + std::advance(__middle, __half); + if (__pred(*__middle)) + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + else + __len = __half; + } + return __first; + } + + + template + _OutputIterator + __remove_copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _Predicate __pred) + { + for (; __first != __last; ++__first) + if (!__pred(__first)) + { + *__result = *__first; + ++__result; + } + return __result; + } +# 665 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _OutputIterator + remove_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, const _Tp& __value) + { + + + + + + + ; + + return std::__remove_copy_if(__first, __last, __result, + __gnu_cxx::__ops::__iter_equals_val(__value)); + } +# 697 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _OutputIterator + remove_copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _Predicate __pred) + { + + + + + + + ; + + return std::__remove_copy_if(__first, __last, __result, + __gnu_cxx::__ops::__pred_iter(__pred)); + } +# 731 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + _OutputIterator + copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _Predicate __pred) + { + + + + + + + ; + + for (; __first != __last; ++__first) + if (__pred(*__first)) + { + *__result = *__first; + ++__result; + } + return __result; + } + + template + _OutputIterator + __copy_n(_InputIterator __first, _Size __n, + _OutputIterator __result, input_iterator_tag) + { + if (__n > 0) + { + while (true) + { + *__result = *__first; + ++__result; + if (--__n > 0) + ++__first; + else + break; + } + } + return __result; + } + + template + inline _OutputIterator + __copy_n(_RandomAccessIterator __first, _Size __n, + _OutputIterator __result, random_access_iterator_tag) + { return std::copy(__first, __first + __n, __result); } +# 794 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _OutputIterator + copy_n(_InputIterator __first, _Size __n, _OutputIterator __result) + { + + + + + + return std::__copy_n(__first, __n, __result, + std::__iterator_category(__first)); + } +# 822 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + pair<_OutputIterator1, _OutputIterator2> + partition_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator1 __out_true, _OutputIterator2 __out_false, + _Predicate __pred) + { +# 837 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + ; + + for (; __first != __last; ++__first) + if (__pred(*__first)) + { + *__out_true = *__first; + ++__out_true; + } + else + { + *__out_false = *__first; + ++__out_false; + } + + return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false); + } + + + template + _ForwardIterator + __remove_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + __first = std::__find_if(__first, __last, __pred); + if (__first == __last) + return __first; + _ForwardIterator __result = __first; + ++__first; + for (; __first != __last; ++__first) + if (!__pred(__first)) + { + *__result = std::move(*__first); + ++__result; + } + return __result; + } +# 891 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _ForwardIterator + remove(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + + + + + + ; + + return std::__remove_if(__first, __last, + __gnu_cxx::__ops::__iter_equals_val(__value)); + } +# 924 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _ForwardIterator + remove_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + + + + + + ; + + return std::__remove_if(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } + + template + _ForwardIterator + __adjacent_find(_ForwardIterator __first, _ForwardIterator __last, + _BinaryPredicate __binary_pred) + { + if (__first == __last) + return __last; + _ForwardIterator __next = __first; + while (++__next != __last) + { + if (__binary_pred(__first, __next)) + return __first; + __first = __next; + } + return __last; + } + + template + _ForwardIterator + __unique(_ForwardIterator __first, _ForwardIterator __last, + _BinaryPredicate __binary_pred) + { + + __first = std::__adjacent_find(__first, __last, __binary_pred); + if (__first == __last) + return __last; + + + _ForwardIterator __dest = __first; + ++__first; + while (++__first != __last) + if (!__binary_pred(__dest, __first)) + *++__dest = std::move(*__first); + return ++__dest; + } +# 990 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _ForwardIterator + unique(_ForwardIterator __first, _ForwardIterator __last) + { + + + + + + ; + + return std::__unique(__first, __last, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 1020 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _ForwardIterator + unique(_ForwardIterator __first, _ForwardIterator __last, + _BinaryPredicate __binary_pred) + { + + + + + + + ; + + return std::__unique(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + + + + + template + _OutputIterator + __unique_copy(_ForwardIterator __first, _ForwardIterator __last, + _OutputIterator __result, _BinaryPredicate __binary_pred, + forward_iterator_tag, output_iterator_tag) + { + + + + + + _ForwardIterator __next = __first; + *__result = *__first; + while (++__next != __last) + if (!__binary_pred(__first, __next)) + { + __first = __next; + *++__result = *__first; + } + return ++__result; + } + + + + + + + + template + _OutputIterator + __unique_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _BinaryPredicate __binary_pred, + input_iterator_tag, output_iterator_tag) + { + + + + + + typename iterator_traits<_InputIterator>::value_type __value = *__first; + __decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred)) + __rebound_pred + = __gnu_cxx::__ops::__iter_comp_val(__binary_pred); + *__result = __value; + while (++__first != __last) + if (!__rebound_pred(__first, __value)) + { + __value = *__first; + *++__result = __value; + } + return ++__result; + } + + + + + + + + template + _ForwardIterator + __unique_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, _BinaryPredicate __binary_pred, + input_iterator_tag, forward_iterator_tag) + { + + + + + *__result = *__first; + while (++__first != __last) + if (!__binary_pred(__result, __first)) + *++__result = *__first; + return ++__result; + } + + + + + + + template + void + __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, + bidirectional_iterator_tag) + { + while (true) + if (__first == __last || __first == --__last) + return; + else + { + std::iter_swap(__first, __last); + ++__first; + } + } + + + + + + + template + void + __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last, + random_access_iterator_tag) + { + if (__first == __last) + return; + --__last; + while (__first < __last) + { + std::iter_swap(__first, __last); + ++__first; + --__last; + } + } +# 1175 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline void + reverse(_BidirectionalIterator __first, _BidirectionalIterator __last) + { + + + + ; + std::__reverse(__first, __last, std::__iterator_category(__first)); + } +# 1202 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + _OutputIterator + reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, + _OutputIterator __result) + { + + + + + + ; + + while (__first != __last) + { + --__last; + *__result = *__last; + ++__result; + } + return __result; + } + + + + + + template + _EuclideanRingElement + __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n) + { + while (__n != 0) + { + _EuclideanRingElement __t = __m % __n; + __m = __n; + __n = __t; + } + return __m; + } + + inline namespace _V2 + { + + + template + _ForwardIterator + __rotate(_ForwardIterator __first, + _ForwardIterator __middle, + _ForwardIterator __last, + forward_iterator_tag) + { + if (__first == __middle) + return __last; + else if (__last == __middle) + return __first; + + _ForwardIterator __first2 = __middle; + do + { + std::iter_swap(__first, __first2); + ++__first; + ++__first2; + if (__first == __middle) + __middle = __first2; + } + while (__first2 != __last); + + _ForwardIterator __ret = __first; + + __first2 = __middle; + + while (__first2 != __last) + { + std::iter_swap(__first, __first2); + ++__first; + ++__first2; + if (__first == __middle) + __middle = __first2; + else if (__first2 == __last) + __first2 = __middle; + } + return __ret; + } + + + template + _BidirectionalIterator + __rotate(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last, + bidirectional_iterator_tag) + { + + + + + if (__first == __middle) + return __last; + else if (__last == __middle) + return __first; + + std::__reverse(__first, __middle, bidirectional_iterator_tag()); + std::__reverse(__middle, __last, bidirectional_iterator_tag()); + + while (__first != __middle && __middle != __last) + { + std::iter_swap(__first, --__last); + ++__first; + } + + if (__first == __middle) + { + std::__reverse(__middle, __last, bidirectional_iterator_tag()); + return __last; + } + else + { + std::__reverse(__first, __middle, bidirectional_iterator_tag()); + return __first; + } + } + + + template + _RandomAccessIterator + __rotate(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last, + random_access_iterator_tag) + { + + + + + if (__first == __middle) + return __last; + else if (__last == __middle) + return __first; + + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _Distance; + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + + _Distance __n = __last - __first; + _Distance __k = __middle - __first; + + if (__k == __n - __k) + { + std::swap_ranges(__first, __middle, __middle); + return __middle; + } + + _RandomAccessIterator __p = __first; + _RandomAccessIterator __ret = __first + (__last - __middle); + + for (;;) + { + if (__k < __n - __k) + { + if (__is_pod(_ValueType) && __k == 1) + { + _ValueType __t = std::move(*__p); + std::move(__p + 1, __p + __n, __p); + *(__p + __n - 1) = std::move(__t); + return __ret; + } + _RandomAccessIterator __q = __p + __k; + for (_Distance __i = 0; __i < __n - __k; ++ __i) + { + std::iter_swap(__p, __q); + ++__p; + ++__q; + } + __n %= __k; + if (__n == 0) + return __ret; + std::swap(__n, __k); + __k = __n - __k; + } + else + { + __k = __n - __k; + if (__is_pod(_ValueType) && __k == 1) + { + _ValueType __t = std::move(*(__p + __n - 1)); + std::move_backward(__p, __p + __n - 1, __p + __n); + *__p = std::move(__t); + return __ret; + } + _RandomAccessIterator __q = __p + __n; + __p = __q - __k; + for (_Distance __i = 0; __i < __n - __k; ++ __i) + { + --__p; + --__q; + std::iter_swap(__p, __q); + } + __n %= __k; + if (__n == 0) + return __ret; + std::swap(__n, __k); + } + } + } +# 1429 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _ForwardIterator + rotate(_ForwardIterator __first, _ForwardIterator __middle, + _ForwardIterator __last) + { + + + + ; + ; + + return std::__rotate(__first, __middle, __last, + std::__iterator_category(__first)); + } + + } +# 1466 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _OutputIterator + rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, + _ForwardIterator __last, _OutputIterator __result) + { + + + + + ; + ; + + return std::copy(__first, __middle, + std::copy(__middle, __last, __result)); + } + + + template + _ForwardIterator + __partition(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred, forward_iterator_tag) + { + if (__first == __last) + return __first; + + while (__pred(*__first)) + if (++__first == __last) + return __first; + + _ForwardIterator __next = __first; + + while (++__next != __last) + if (__pred(*__next)) + { + std::iter_swap(__first, __next); + ++__first; + } + + return __first; + } + + + template + _BidirectionalIterator + __partition(_BidirectionalIterator __first, _BidirectionalIterator __last, + _Predicate __pred, bidirectional_iterator_tag) + { + while (true) + { + while (true) + if (__first == __last) + return __first; + else if (__pred(*__first)) + ++__first; + else + break; + --__last; + while (true) + if (__first == __last) + return __first; + else if (!bool(__pred(*__last))) + --__last; + else + break; + std::iter_swap(__first, __last); + ++__first; + } + } +# 1543 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + _ForwardIterator + __stable_partition_adaptive(_ForwardIterator __first, + _ForwardIterator __last, + _Predicate __pred, _Distance __len, + _Pointer __buffer, + _Distance __buffer_size) + { + if (__len == 1) + return __first; + + if (__len <= __buffer_size) + { + _ForwardIterator __result1 = __first; + _Pointer __result2 = __buffer; + + + + + *__result2 = std::move(*__first); + ++__result2; + ++__first; + for (; __first != __last; ++__first) + if (__pred(__first)) + { + *__result1 = std::move(*__first); + ++__result1; + } + else + { + *__result2 = std::move(*__first); + ++__result2; + } + + std::move(__buffer, __result2, __result1); + return __result1; + } + + _ForwardIterator __middle = __first; + std::advance(__middle, __len / 2); + _ForwardIterator __left_split = + std::__stable_partition_adaptive(__first, __middle, __pred, + __len / 2, __buffer, + __buffer_size); + + + + _Distance __right_len = __len - __len / 2; + _ForwardIterator __right_split = + std::__find_if_not_n(__middle, __right_len, __pred); + + if (__right_len) + __right_split = + std::__stable_partition_adaptive(__right_split, __last, __pred, + __right_len, + __buffer, __buffer_size); + + std::rotate(__left_split, __middle, __right_split); + std::advance(__left_split, std::distance(__middle, __right_split)); + return __left_split; + } + + template + _ForwardIterator + __stable_partition(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + __first = std::__find_if_not(__first, __last, __pred); + + if (__first == __last) + return __first; + + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first, __last); + return + std::__stable_partition_adaptive(__first, __last, __pred, + _DistanceType(__buf.requested_size()), + __buf.begin(), + _DistanceType(__buf.size())); + } +# 1646 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _ForwardIterator + stable_partition(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + + + + + + ; + + return std::__stable_partition(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } + + + template + void + __heap_select(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last, _Compare __comp) + { + std::__make_heap(__first, __middle, __comp); + for (_RandomAccessIterator __i = __middle; __i < __last; ++__i) + if (__comp(__i, __first)) + std::__pop_heap(__first, __middle, __i, __comp); + } + + + + template + _RandomAccessIterator + __partial_sort_copy(_InputIterator __first, _InputIterator __last, + _RandomAccessIterator __result_first, + _RandomAccessIterator __result_last, + _Compare __comp) + { + typedef typename iterator_traits<_InputIterator>::value_type + _InputValueType; + typedef iterator_traits<_RandomAccessIterator> _RItTraits; + typedef typename _RItTraits::difference_type _DistanceType; + + if (__result_first == __result_last) + return __result_last; + _RandomAccessIterator __result_real_last = __result_first; + while (__first != __last && __result_real_last != __result_last) + { + *__result_real_last = *__first; + ++__result_real_last; + ++__first; + } + + std::__make_heap(__result_first, __result_real_last, __comp); + while (__first != __last) + { + if (__comp(__first, __result_first)) + std::__adjust_heap(__result_first, _DistanceType(0), + _DistanceType(__result_real_last + - __result_first), + _InputValueType(*__first), __comp); + ++__first; + } + std::__sort_heap(__result_first, __result_real_last, __comp); + return __result_real_last; + } +# 1732 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _RandomAccessIterator + partial_sort_copy(_InputIterator __first, _InputIterator __last, + _RandomAccessIterator __result_first, + _RandomAccessIterator __result_last) + { +# 1752 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + ; + ; + ; + + return std::__partial_sort_copy(__first, __last, + __result_first, __result_last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 1781 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _RandomAccessIterator + partial_sort_copy(_InputIterator __first, _InputIterator __last, + _RandomAccessIterator __result_first, + _RandomAccessIterator __result_last, + _Compare __comp) + { +# 1806 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + ; + ; + ; + + return std::__partial_sort_copy(__first, __last, + __result_first, __result_last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + + template + void + __unguarded_linear_insert(_RandomAccessIterator __last, + _Compare __comp) + { + typename iterator_traits<_RandomAccessIterator>::value_type + __val = std::move(*__last); + _RandomAccessIterator __next = __last; + --__next; + while (__comp(__val, __next)) + { + *__last = std::move(*__next); + __last = __next; + --__next; + } + *__last = std::move(__val); + } + + + template + void + __insertion_sort(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + if (__first == __last) return; + + for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) + { + if (__comp(__i, __first)) + { + typename iterator_traits<_RandomAccessIterator>::value_type + __val = std::move(*__i); + std::move_backward(__first, __i, __i + 1); + *__first = std::move(__val); + } + else + std::__unguarded_linear_insert(__i, + __gnu_cxx::__ops::__val_comp_iter(__comp)); + } + } + + + template + inline void + __unguarded_insertion_sort(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + for (_RandomAccessIterator __i = __first; __i != __last; ++__i) + std::__unguarded_linear_insert(__i, + __gnu_cxx::__ops::__val_comp_iter(__comp)); + } + + + + + + enum { _S_threshold = 16 }; + + + template + void + __final_insertion_sort(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + if (__last - __first > int(_S_threshold)) + { + std::__insertion_sort(__first, __first + int(_S_threshold), __comp); + std::__unguarded_insertion_sort(__first + int(_S_threshold), __last, + __comp); + } + else + std::__insertion_sort(__first, __last, __comp); + } + + + template + _RandomAccessIterator + __unguarded_partition(_RandomAccessIterator __first, + _RandomAccessIterator __last, + _RandomAccessIterator __pivot, _Compare __comp) + { + while (true) + { + while (__comp(__first, __pivot)) + ++__first; + --__last; + while (__comp(__pivot, __last)) + --__last; + if (!(__first < __last)) + return __first; + std::iter_swap(__first, __last); + ++__first; + } + } + + + template + inline _RandomAccessIterator + __unguarded_partition_pivot(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + _RandomAccessIterator __mid = __first + (__last - __first) / 2; + std::__move_median_to_first(__first, __first + 1, __mid, __last - 1, + __comp); + return std::__unguarded_partition(__first + 1, __last, __first, __comp); + } + + template + inline void + __partial_sort(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last, + _Compare __comp) + { + std::__heap_select(__first, __middle, __last, __comp); + std::__sort_heap(__first, __middle, __comp); + } + + + template + void + __introsort_loop(_RandomAccessIterator __first, + _RandomAccessIterator __last, + _Size __depth_limit, _Compare __comp) + { + while (__last - __first > int(_S_threshold)) + { + if (__depth_limit == 0) + { + std::__partial_sort(__first, __last, __last, __comp); + return; + } + --__depth_limit; + _RandomAccessIterator __cut = + std::__unguarded_partition_pivot(__first, __last, __comp); + std::__introsort_loop(__cut, __last, __depth_limit, __comp); + __last = __cut; + } + } + + + + template + inline void + __sort(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + if (__first != __last) + { + std::__introsort_loop(__first, __last, + std::__lg(__last - __first) * 2, + __comp); + std::__final_insertion_sort(__first, __last, __comp); + } + } + + template + void + __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last, _Size __depth_limit, + _Compare __comp) + { + while (__last - __first > 3) + { + if (__depth_limit == 0) + { + std::__heap_select(__first, __nth + 1, __last, __comp); + + std::iter_swap(__first, __nth); + return; + } + --__depth_limit; + _RandomAccessIterator __cut = + std::__unguarded_partition_pivot(__first, __last, __comp); + if (__cut <= __nth) + __first = __cut; + else + __last = __cut; + } + std::__insertion_sort(__first, __last, __comp); + } +# 2018 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _ForwardIterator + lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + + + + + + ; + + return std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_comp_val(__comp)); + } + + template + _ForwardIterator + __upper_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len = std::distance(__first, __last); + + while (__len > 0) + { + _DistanceType __half = __len >> 1; + _ForwardIterator __middle = __first; + std::advance(__middle, __half); + if (__comp(__val, __middle)) + __len = __half; + else + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + } + return __first; + } +# 2072 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _ForwardIterator + upper_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + + + + + ; + + return std::__upper_bound(__first, __last, __val, + __gnu_cxx::__ops::__val_less_iter()); + } +# 2102 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _ForwardIterator + upper_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + + + + + + ; + + return std::__upper_bound(__first, __last, __val, + __gnu_cxx::__ops::__val_comp_iter(__comp)); + } + + template + pair<_ForwardIterator, _ForwardIterator> + __equal_range(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, + _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it) + { + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len = std::distance(__first, __last); + + while (__len > 0) + { + _DistanceType __half = __len >> 1; + _ForwardIterator __middle = __first; + std::advance(__middle, __half); + if (__comp_it_val(__middle, __val)) + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + else if (__comp_val_it(__val, __middle)) + __len = __half; + else + { + _ForwardIterator __left + = std::__lower_bound(__first, __middle, __val, __comp_it_val); + std::advance(__first, __len); + _ForwardIterator __right + = std::__upper_bound(++__middle, __first, __val, __comp_val_it); + return pair<_ForwardIterator, _ForwardIterator>(__left, __right); + } + } + return pair<_ForwardIterator, _ForwardIterator>(__first, __first); + } +# 2173 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline pair<_ForwardIterator, _ForwardIterator> + equal_range(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + + + + + + + ; + ; + + return std::__equal_range(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val(), + __gnu_cxx::__ops::__val_less_iter()); + } +# 2209 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline pair<_ForwardIterator, _ForwardIterator> + equal_range(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + + + + + + + + ; + + ; + + return std::__equal_range(__first, __last, __val, + __gnu_cxx::__ops::__iter_comp_val(__comp), + __gnu_cxx::__ops::__val_comp_iter(__comp)); + } +# 2242 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + bool + binary_search(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + + + + + ; + ; + + _ForwardIterator __i + = std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val()); + return __i != __last && !(__val < *__i); + } +# 2275 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + bool + binary_search(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + + + + + + ; + + ; + + _ForwardIterator __i + = std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_comp_val(__comp)); + return __i != __last && !bool(__comp(__val, *__i)); + } + + + + + template + void + __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + { + if (__comp(__first2, __first1)) + { + *__result = std::move(*__first2); + ++__first2; + } + else + { + *__result = std::move(*__first1); + ++__first1; + } + ++__result; + } + if (__first1 != __last1) + std::move(__first1, __last1, __result); + } + + + template + void + __move_merge_adaptive_backward(_BidirectionalIterator1 __first1, + _BidirectionalIterator1 __last1, + _BidirectionalIterator2 __first2, + _BidirectionalIterator2 __last2, + _BidirectionalIterator3 __result, + _Compare __comp) + { + if (__first1 == __last1) + { + std::move_backward(__first2, __last2, __result); + return; + } + else if (__first2 == __last2) + return; + + --__last1; + --__last2; + while (true) + { + if (__comp(__last2, __last1)) + { + *--__result = std::move(*__last1); + if (__first1 == __last1) + { + std::move_backward(__first2, ++__last2, __result); + return; + } + --__last1; + } + else + { + *--__result = std::move(*__last2); + if (__first2 == __last2) + return; + --__last2; + } + } + } + + + template + _BidirectionalIterator1 + __rotate_adaptive(_BidirectionalIterator1 __first, + _BidirectionalIterator1 __middle, + _BidirectionalIterator1 __last, + _Distance __len1, _Distance __len2, + _BidirectionalIterator2 __buffer, + _Distance __buffer_size) + { + _BidirectionalIterator2 __buffer_end; + if (__len1 > __len2 && __len2 <= __buffer_size) + { + if (__len2) + { + __buffer_end = std::move(__middle, __last, __buffer); + std::move_backward(__first, __middle, __last); + return std::move(__buffer, __buffer_end, __first); + } + else + return __first; + } + else if (__len1 <= __buffer_size) + { + if (__len1) + { + __buffer_end = std::move(__first, __middle, __buffer); + std::move(__middle, __last, __first); + return std::move_backward(__buffer, __buffer_end, __last); + } + else + return __last; + } + else + { + std::rotate(__first, __middle, __last); + std::advance(__first, std::distance(__middle, __last)); + return __first; + } + } + + + template + void + __merge_adaptive(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last, + _Distance __len1, _Distance __len2, + _Pointer __buffer, _Distance __buffer_size, + _Compare __comp) + { + if (__len1 <= __len2 && __len1 <= __buffer_size) + { + _Pointer __buffer_end = std::move(__first, __middle, __buffer); + std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last, + __first, __comp); + } + else if (__len2 <= __buffer_size) + { + _Pointer __buffer_end = std::move(__middle, __last, __buffer); + std::__move_merge_adaptive_backward(__first, __middle, __buffer, + __buffer_end, __last, __comp); + } + else + { + _BidirectionalIterator __first_cut = __first; + _BidirectionalIterator __second_cut = __middle; + _Distance __len11 = 0; + _Distance __len22 = 0; + if (__len1 > __len2) + { + __len11 = __len1 / 2; + std::advance(__first_cut, __len11); + __second_cut + = std::__lower_bound(__middle, __last, *__first_cut, + __gnu_cxx::__ops::__iter_comp_val(__comp)); + __len22 = std::distance(__middle, __second_cut); + } + else + { + __len22 = __len2 / 2; + std::advance(__second_cut, __len22); + __first_cut + = std::__upper_bound(__first, __middle, *__second_cut, + __gnu_cxx::__ops::__val_comp_iter(__comp)); + __len11 = std::distance(__first, __first_cut); + } + + _BidirectionalIterator __new_middle + = std::__rotate_adaptive(__first_cut, __middle, __second_cut, + __len1 - __len11, __len22, __buffer, + __buffer_size); + std::__merge_adaptive(__first, __first_cut, __new_middle, __len11, + __len22, __buffer, __buffer_size, __comp); + std::__merge_adaptive(__new_middle, __second_cut, __last, + __len1 - __len11, + __len2 - __len22, __buffer, + __buffer_size, __comp); + } + } + + + template + void + __merge_without_buffer(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last, + _Distance __len1, _Distance __len2, + _Compare __comp) + { + if (__len1 == 0 || __len2 == 0) + return; + + if (__len1 + __len2 == 2) + { + if (__comp(__middle, __first)) + std::iter_swap(__first, __middle); + return; + } + + _BidirectionalIterator __first_cut = __first; + _BidirectionalIterator __second_cut = __middle; + _Distance __len11 = 0; + _Distance __len22 = 0; + if (__len1 > __len2) + { + __len11 = __len1 / 2; + std::advance(__first_cut, __len11); + __second_cut + = std::__lower_bound(__middle, __last, *__first_cut, + __gnu_cxx::__ops::__iter_comp_val(__comp)); + __len22 = std::distance(__middle, __second_cut); + } + else + { + __len22 = __len2 / 2; + std::advance(__second_cut, __len22); + __first_cut + = std::__upper_bound(__first, __middle, *__second_cut, + __gnu_cxx::__ops::__val_comp_iter(__comp)); + __len11 = std::distance(__first, __first_cut); + } + + std::rotate(__first_cut, __middle, __second_cut); + _BidirectionalIterator __new_middle = __first_cut; + std::advance(__new_middle, std::distance(__middle, __second_cut)); + std::__merge_without_buffer(__first, __first_cut, __new_middle, + __len11, __len22, __comp); + std::__merge_without_buffer(__new_middle, __second_cut, __last, + __len1 - __len11, __len2 - __len22, __comp); + } + + template + void + __inplace_merge(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last, + _Compare __comp) + { + typedef typename iterator_traits<_BidirectionalIterator>::value_type + _ValueType; + typedef typename iterator_traits<_BidirectionalIterator>::difference_type + _DistanceType; + + if (__first == __middle || __middle == __last) + return; + + const _DistanceType __len1 = std::distance(__first, __middle); + const _DistanceType __len2 = std::distance(__middle, __last); + + typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf; + _TmpBuf __buf(__first, __last); + + if (__buf.begin() == 0) + std::__merge_without_buffer + (__first, __middle, __last, __len1, __len2, __comp); + else + std::__merge_adaptive + (__first, __middle, __last, __len1, __len2, __buf.begin(), + _DistanceType(__buf.size()), __comp); + } +# 2569 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline void + inplace_merge(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last) + { + + + + + + ; + ; + ; + + std::__inplace_merge(__first, __middle, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 2610 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline void + inplace_merge(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last, + _Compare __comp) + { + + + + + + + ; + ; + ; + + std::__inplace_merge(__first, __middle, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + + + template + _OutputIterator + __move_merge(_InputIterator __first1, _InputIterator __last1, + _InputIterator __first2, _InputIterator __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + { + if (__comp(__first2, __first1)) + { + *__result = std::move(*__first2); + ++__first2; + } + else + { + *__result = std::move(*__first1); + ++__first1; + } + ++__result; + } + return std::move(__first2, __last2, std::move(__first1, __last1, __result)); + + + } + + template + void + __merge_sort_loop(_RandomAccessIterator1 __first, + _RandomAccessIterator1 __last, + _RandomAccessIterator2 __result, _Distance __step_size, + _Compare __comp) + { + const _Distance __two_step = 2 * __step_size; + + while (__last - __first >= __two_step) + { + __result = std::__move_merge(__first, __first + __step_size, + __first + __step_size, + __first + __two_step, + __result, __comp); + __first += __two_step; + } + __step_size = std::min(_Distance(__last - __first), __step_size); + + std::__move_merge(__first, __first + __step_size, + __first + __step_size, __last, __result, __comp); + } + + template + void + __chunk_insertion_sort(_RandomAccessIterator __first, + _RandomAccessIterator __last, + _Distance __chunk_size, _Compare __comp) + { + while (__last - __first >= __chunk_size) + { + std::__insertion_sort(__first, __first + __chunk_size, __comp); + __first += __chunk_size; + } + std::__insertion_sort(__first, __last, __comp); + } + + enum { _S_chunk_size = 7 }; + + template + void + __merge_sort_with_buffer(_RandomAccessIterator __first, + _RandomAccessIterator __last, + _Pointer __buffer, _Compare __comp) + { + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _Distance; + + const _Distance __len = __last - __first; + const _Pointer __buffer_last = __buffer + __len; + + _Distance __step_size = _S_chunk_size; + std::__chunk_insertion_sort(__first, __last, __step_size, __comp); + + while (__step_size < __len) + { + std::__merge_sort_loop(__first, __last, __buffer, + __step_size, __comp); + __step_size *= 2; + std::__merge_sort_loop(__buffer, __buffer_last, __first, + __step_size, __comp); + __step_size *= 2; + } + } + + template + void + __stable_sort_adaptive(_RandomAccessIterator __first, + _RandomAccessIterator __last, + _Pointer __buffer, _Distance __buffer_size, + _Compare __comp) + { + const _Distance __len = (__last - __first + 1) / 2; + const _RandomAccessIterator __middle = __first + __len; + if (__len > __buffer_size) + { + std::__stable_sort_adaptive(__first, __middle, __buffer, + __buffer_size, __comp); + std::__stable_sort_adaptive(__middle, __last, __buffer, + __buffer_size, __comp); + } + else + { + std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp); + std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp); + } + std::__merge_adaptive(__first, __middle, __last, + _Distance(__middle - __first), + _Distance(__last - __middle), + __buffer, __buffer_size, + __comp); + } + + + template + void + __inplace_stable_sort(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + if (__last - __first < 15) + { + std::__insertion_sort(__first, __last, __comp); + return; + } + _RandomAccessIterator __middle = __first + (__last - __first) / 2; + std::__inplace_stable_sort(__first, __middle, __comp); + std::__inplace_stable_sort(__middle, __last, __comp); + std::__merge_without_buffer(__first, __middle, __last, + __middle - __first, + __last - __middle, + __comp); + } +# 2782 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + bool + __includes(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + if (__comp(__first2, __first1)) + return false; + else if (__comp(__first1, __first2)) + ++__first1; + else + { + ++__first1; + ++__first2; + } + + return __first2 == __last2; + } +# 2821 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline bool + includes(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2) + { +# 2835 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + ; + ; + ; + ; + + return std::__includes(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 2865 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline bool + includes(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _Compare __comp) + { +# 2881 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + ; + ; + ; + ; + + return std::__includes(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 2900 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + bool + __next_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last, _Compare __comp) + { + if (__first == __last) + return false; + _BidirectionalIterator __i = __first; + ++__i; + if (__i == __last) + return false; + __i = __last; + --__i; + + for(;;) + { + _BidirectionalIterator __ii = __i; + --__i; + if (__comp(__i, __ii)) + { + _BidirectionalIterator __j = __last; + while (!__comp(__i, --__j)) + {} + std::iter_swap(__i, __j); + std::__reverse(__ii, __last, + std::__iterator_category(__first)); + return true; + } + if (__i == __first) + { + std::__reverse(__first, __last, + std::__iterator_category(__first)); + return false; + } + } + } +# 2949 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline bool + next_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last) + { + + + + + + ; + ; + + return std::__next_permutation + (__first, __last, __gnu_cxx::__ops::__iter_less_iter()); + } +# 2981 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline bool + next_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last, _Compare __comp) + { + + + + + + + ; + ; + + return std::__next_permutation + (__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + bool + __prev_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last, _Compare __comp) + { + if (__first == __last) + return false; + _BidirectionalIterator __i = __first; + ++__i; + if (__i == __last) + return false; + __i = __last; + --__i; + + for(;;) + { + _BidirectionalIterator __ii = __i; + --__i; + if (__comp(__ii, __i)) + { + _BidirectionalIterator __j = __last; + while (!__comp(--__j, __i)) + {} + std::iter_swap(__i, __j); + std::__reverse(__ii, __last, + std::__iterator_category(__first)); + return true; + } + if (__i == __first) + { + std::__reverse(__first, __last, + std::__iterator_category(__first)); + return false; + } + } + } +# 3049 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline bool + prev_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last) + { + + + + + + ; + ; + + return std::__prev_permutation(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 3081 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline bool + prev_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last, _Compare __comp) + { + + + + + + + ; + ; + + return std::__prev_permutation(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + + + + template + _OutputIterator + __replace_copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, + _Predicate __pred, const _Tp& __new_value) + { + for (; __first != __last; ++__first, (void)++__result) + if (__pred(__first)) + *__result = __new_value; + else + *__result = *__first; + return __result; + } +# 3131 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _OutputIterator + replace_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, + const _Tp& __old_value, const _Tp& __new_value) + { + + + + + + + ; + + return std::__replace_copy_if(__first, __last, __result, + __gnu_cxx::__ops::__iter_equals_val(__old_value), + __new_value); + } +# 3165 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _OutputIterator + replace_copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, + _Predicate __pred, const _Tp& __new_value) + { + + + + + + + ; + + return std::__replace_copy_if(__first, __last, __result, + __gnu_cxx::__ops::__pred_iter(__pred), + __new_value); + } + + template + typename iterator_traits<_InputIterator>::difference_type + __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { + typename iterator_traits<_InputIterator>::difference_type __n = 0; + for (; __first != __last; ++__first) + if (__pred(__first)) + ++__n; + return __n; + } +# 3204 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline bool + is_sorted(_ForwardIterator __first, _ForwardIterator __last) + { return std::is_sorted_until(__first, __last) == __last; } +# 3218 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline bool + is_sorted(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { return std::is_sorted_until(__first, __last, __comp) == __last; } + + template + _ForwardIterator + __is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + if (__first == __last) + return __last; + + _ForwardIterator __next = __first; + for (++__next; __next != __last; __first = __next, (void)++__next) + if (__comp(__next, __first)) + return __next; + return __next; + } +# 3247 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _ForwardIterator + is_sorted_until(_ForwardIterator __first, _ForwardIterator __last) + { + + + + + ; + ; + + return std::__is_sorted_until(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 3271 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _ForwardIterator + is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + + + + + + ; + ; + + return std::__is_sorted_until(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 3296 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + constexpr + inline pair + minmax(const _Tp& __a, const _Tp& __b) + { + + + + return __b < __a ? pair(__b, __a) + : pair(__a, __b); + } +# 3317 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + constexpr + inline pair + minmax(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + return __comp(__b, __a) ? pair(__b, __a) + : pair(__a, __b); + } + + template + constexpr + pair<_ForwardIterator, _ForwardIterator> + __minmax_element(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + _ForwardIterator __next = __first; + if (__first == __last + || ++__next == __last) + return std::make_pair(__first, __first); + + _ForwardIterator __min{}, __max{}; + if (__comp(__next, __first)) + { + __min = __next; + __max = __first; + } + else + { + __min = __first; + __max = __next; + } + + __first = __next; + ++__first; + + while (__first != __last) + { + __next = __first; + if (++__next == __last) + { + if (__comp(__first, __min)) + __min = __first; + else if (!__comp(__first, __max)) + __max = __first; + break; + } + + if (__comp(__next, __first)) + { + if (__comp(__next, __min)) + __min = __next; + if (!__comp(__first, __max)) + __max = __first; + } + else + { + if (__comp(__first, __min)) + __min = __first; + if (!__comp(__next, __max)) + __max = __next; + } + + __first = __next; + ++__first; + } + + return std::make_pair(__min, __max); + } +# 3397 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + constexpr + inline pair<_ForwardIterator, _ForwardIterator> + minmax_element(_ForwardIterator __first, _ForwardIterator __last) + { + + + + + ; + ; + + return std::__minmax_element(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 3425 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + constexpr + inline pair<_ForwardIterator, _ForwardIterator> + minmax_element(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + + + + + + ; + ; + + return std::__minmax_element(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + + template + constexpr + inline _Tp + min(initializer_list<_Tp> __l) + { return *std::min_element(__l.begin(), __l.end()); } + + template + constexpr + inline _Tp + min(initializer_list<_Tp> __l, _Compare __comp) + { return *std::min_element(__l.begin(), __l.end(), __comp); } + + template + constexpr + inline _Tp + max(initializer_list<_Tp> __l) + { return *std::max_element(__l.begin(), __l.end()); } + + template + constexpr + inline _Tp + max(initializer_list<_Tp> __l, _Compare __comp) + { return *std::max_element(__l.begin(), __l.end(), __comp); } + + template + constexpr + inline pair<_Tp, _Tp> + minmax(initializer_list<_Tp> __l) + { + pair __p = + std::minmax_element(__l.begin(), __l.end()); + return std::make_pair(*__p.first, *__p.second); + } + + template + constexpr + inline pair<_Tp, _Tp> + minmax(initializer_list<_Tp> __l, _Compare __comp) + { + pair __p = + std::minmax_element(__l.begin(), __l.end(), __comp); + return std::make_pair(*__p.first, *__p.second); + } + + template + bool + __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _BinaryPredicate __pred) + { + + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!__pred(__first1, __first2)) + break; + + if (__first1 == __last1) + return true; + + + + _ForwardIterator2 __last2 = __first2; + std::advance(__last2, std::distance(__first1, __last1)); + for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) + { + if (__scan != std::__find_if(__first1, __scan, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) + continue; + + auto __matches + = std::__count_if(__first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); + if (0 == __matches || + std::__count_if(__scan, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) + != __matches) + return false; + } + return true; + } +# 3537 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + + ; + + return std::__is_permutation(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 3568 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _BinaryPredicate __pred) + { + + + + + + + ; + + return std::__is_permutation(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_comp_iter(__pred)); + } + + + template + bool + __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __pred) + { + using _Cat1 + = typename iterator_traits<_ForwardIterator1>::iterator_category; + using _Cat2 + = typename iterator_traits<_ForwardIterator2>::iterator_category; + using _It1_is_RA = is_same<_Cat1, random_access_iterator_tag>; + using _It2_is_RA = is_same<_Cat2, random_access_iterator_tag>; + constexpr bool __ra_iters = _It1_is_RA() && _It2_is_RA(); + if (__ra_iters) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + } + + + + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!__pred(__first1, __first2)) + break; + + if (__ra_iters) + { + if (__first1 == __last1) + return true; + } + else + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 == 0 && __d2 == 0) + return true; + if (__d1 != __d2) + return false; + } + + for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) + { + if (__scan != std::__find_if(__first1, __scan, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) + continue; + + auto __matches = std::__count_if(__first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); + if (0 == __matches + || std::__count_if(__scan, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) + != __matches) + return false; + } + return true; + } +# 3661 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2) + { + ; + ; + + return + std::__is_permutation(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 3688 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __pred) + { + ; + ; + + return std::__is_permutation(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__pred)); + } +# 3716 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + void + shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last, + _UniformRandomNumberGenerator&& __g) + { + + + + ; + + if (__first == __last) + return; + + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + typedef typename std::make_unsigned<_DistanceType>::type __ud_type; + typedef typename std::uniform_int_distribution<__ud_type> __distr_type; + typedef typename __distr_type::param_type __p_type; + __distr_type __d; + + for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) + std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first))); + } +# 3761 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + _Function + for_each(_InputIterator __first, _InputIterator __last, _Function __f) + { + + + ; + for (; __first != __last; ++__first) + __f(*__first); + return std::move(__f); + } +# 3782 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _InputIterator + find(_InputIterator __first, _InputIterator __last, + const _Tp& __val) + { + + + + + ; + return std::__find_if(__first, __last, + __gnu_cxx::__ops::__iter_equals_val(__val)); + } +# 3806 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _InputIterator + find_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred) + { + + + + + ; + + return std::__find_if(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } +# 3837 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + _InputIterator + find_first_of(_InputIterator __first1, _InputIterator __last1, + _ForwardIterator __first2, _ForwardIterator __last2) + { + + + + + + + ; + ; + + for (; __first1 != __last1; ++__first1) + for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter) + if (*__first1 == *__iter) + return __first1; + return __last1; + } +# 3877 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + _InputIterator + find_first_of(_InputIterator __first1, _InputIterator __last1, + _ForwardIterator __first2, _ForwardIterator __last2, + _BinaryPredicate __comp) + { + + + + + + + ; + ; + + for (; __first1 != __last1; ++__first1) + for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter) + if (__comp(*__first1, *__iter)) + return __first1; + return __last1; + } +# 3909 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _ForwardIterator + adjacent_find(_ForwardIterator __first, _ForwardIterator __last) + { + + + + + ; + + return std::__adjacent_find(__first, __last, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 3934 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _ForwardIterator + adjacent_find(_ForwardIterator __first, _ForwardIterator __last, + _BinaryPredicate __binary_pred) + { + + + + + + ; + + return std::__adjacent_find(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } +# 3959 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline typename iterator_traits<_InputIterator>::difference_type + count(_InputIterator __first, _InputIterator __last, const _Tp& __value) + { + + + + + ; + + return std::__count_if(__first, __last, + __gnu_cxx::__ops::__iter_equals_val(__value)); + } +# 3982 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline typename iterator_traits<_InputIterator>::difference_type + count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { + + + + + ; + + return std::__count_if(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } +# 4022 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _ForwardIterator1 + search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2) + { + + + + + + + ; + ; + + return std::__search(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 4061 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _ForwardIterator1 + search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __predicate) + { + + + + + + + ; + ; + + return std::__search(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__predicate)); + } +# 4096 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _ForwardIterator + search_n(_ForwardIterator __first, _ForwardIterator __last, + _Integer __count, const _Tp& __val) + { + + + + + ; + + return std::__search_n(__first, __last, __count, + __gnu_cxx::__ops::__iter_equals_val(__val)); + } +# 4129 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _ForwardIterator + search_n(_ForwardIterator __first, _ForwardIterator __last, + _Integer __count, const _Tp& __val, + _BinaryPredicate __binary_pred) + { + + + + + ; + + return std::__search_n(__first, __last, __count, + __gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val)); + } +# 4163 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + _OutputIterator + transform(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _UnaryOperation __unary_op) + { + + + + + + ; + + for (; __first != __last; ++__first, (void)++__result) + *__result = __unary_op(*__first); + return __result; + } +# 4200 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + _OutputIterator + transform(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _OutputIterator __result, + _BinaryOperation __binary_op) + { + + + + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2, ++__result) + *__result = __binary_op(*__first1, *__first2); + return __result; + } +# 4233 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + void + replace(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __old_value, const _Tp& __new_value) + { + + + + + + + + ; + + for (; __first != __last; ++__first) + if (*__first == __old_value) + *__first = __new_value; + } +# 4265 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + void + replace_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred, const _Tp& __new_value) + { + + + + + + + + ; + + for (; __first != __last; ++__first) + if (__pred(*__first)) + *__first = __new_value; + } +# 4297 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + void + generate(_ForwardIterator __first, _ForwardIterator __last, + _Generator __gen) + { + + + + + ; + + for (; __first != __last; ++__first) + *__first = __gen(); + } +# 4328 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + _OutputIterator + generate_n(_OutputIterator __first, _Size __n, _Generator __gen) + { + + + + + + for (__decltype(__n + 0) __niter = __n; + __niter > 0; --__niter, ++__first) + *__first = __gen(); + return __first; + } +# 4364 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _OutputIterator + unique_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result) + { + + + + + + + ; + + if (__first == __last) + return __result; + return std::__unique_copy(__first, __last, __result, + __gnu_cxx::__ops::__iter_equal_to_iter(), + std::__iterator_category(__first), + std::__iterator_category(__result)); + } +# 4404 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _OutputIterator + unique_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, + _BinaryPredicate __binary_pred) + { + + + + + ; + + if (__first == __last) + return __result; + return std::__unique_copy(__first, __last, __result, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred), + std::__iterator_category(__first), + std::__iterator_category(__result)); + } +# 4437 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline void + random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + + + + ; + + if (__first != __last) + for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) + { + + _RandomAccessIterator __j = __first + + std::rand() % ((__i - __first) + 1); + if (__i != __j) + std::iter_swap(__i, __j); + } + } +# 4472 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + void + random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last, + + _RandomNumberGenerator&& __rand) + + + + { + + + + ; + + if (__first == __last) + return; + for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) + { + _RandomAccessIterator __j = __first + __rand((__i - __first) + 1); + if (__i != __j) + std::iter_swap(__i, __j); + } + } +# 4512 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _ForwardIterator + partition(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + + + + + + ; + + return std::__partition(__first, __last, __pred, + std::__iterator_category(__first)); + } +# 4545 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline void + partial_sort(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last) + { + + + + + + ; + ; + ; + + std::__partial_sort(__first, __middle, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 4583 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline void + partial_sort(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last, + _Compare __comp) + { + + + + + + + ; + ; + ; + + std::__partial_sort(__first, __middle, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 4619 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline void + nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last) + { + + + + + + ; + ; + ; + + if (__first == __last || __nth == __last) + return; + + std::__introselect(__first, __nth, __last, + std::__lg(__last - __first) * 2, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 4658 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline void + nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last, _Compare __comp) + { + + + + + + + ; + ; + ; + + if (__first == __last || __nth == __last) + return; + + std::__introselect(__first, __nth, __last, + std::__lg(__last - __first) * 2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 4695 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline void + sort(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + + + + + + ; + ; + + std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter()); + } +# 4725 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline void + sort(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + + + + + + + ; + ; + + std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + _OutputIterator + __merge(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + { + if (__comp(__first2, __first1)) + { + *__result = *__first2; + ++__first2; + } + else + { + *__result = *__first1; + ++__first1; + } + ++__result; + } + return std::copy(__first2, __last2, + std::copy(__first1, __last1, __result)); + } +# 4786 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _OutputIterator + merge(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result) + { +# 4803 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + ; + ; + ; + ; + + return std::__merge(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 4836 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _OutputIterator + merge(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { +# 4853 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + ; + ; + ; + ; + + return std::__merge(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + inline void + __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf; + _TmpBuf __buf(__first, __last); + + if (__buf.begin() == 0) + std::__inplace_stable_sort(__first, __last, __comp); + else + std::__stable_sort_adaptive(__first, __last, __buf.begin(), + _DistanceType(__buf.size()), __comp); + } +# 4900 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline void + stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + + + + + + ; + ; + + std::__stable_sort(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 4934 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline void + stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + + + + + + + ; + ; + + std::__stable_sort(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + _OutputIterator + __set_union(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + { + if (__comp(__first1, __first2)) + { + *__result = *__first1; + ++__first1; + } + else if (__comp(__first2, __first1)) + { + *__result = *__first2; + ++__first2; + } + else + { + *__result = *__first1; + ++__first1; + ++__first2; + } + ++__result; + } + return std::copy(__first2, __last2, + std::copy(__first1, __last1, __result)); + } +# 5002 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _OutputIterator + set_union(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result) + { +# 5022 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + ; + ; + ; + ; + + return std::__set_union(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5051 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _OutputIterator + set_union(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { +# 5071 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + ; + ; + ; + ; + + return std::__set_union(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + _OutputIterator + __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + if (__comp(__first1, __first2)) + ++__first1; + else if (__comp(__first2, __first1)) + ++__first2; + else + { + *__result = *__first1; + ++__first1; + ++__first2; + ++__result; + } + return __result; + } +# 5121 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _OutputIterator + set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result) + { +# 5139 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + ; + ; + ; + ; + + return std::__set_intersection(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5169 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _OutputIterator + set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { +# 5187 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + ; + ; + ; + ; + + return std::__set_intersection(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + _OutputIterator + __set_difference(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + if (__comp(__first1, __first2)) + { + *__result = *__first1; + ++__first1; + ++__result; + } + else if (__comp(__first2, __first1)) + ++__first2; + else + { + ++__first1; + ++__first2; + } + return std::copy(__first1, __last1, __result); + } +# 5241 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _OutputIterator + set_difference(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result) + { +# 5259 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + ; + ; + ; + ; + + return std::__set_difference(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5291 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _OutputIterator + set_difference(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { +# 5309 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + ; + ; + ; + ; + + return std::__set_difference(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + _OutputIterator + __set_symmetric_difference(_InputIterator1 __first1, + _InputIterator1 __last1, + _InputIterator2 __first2, + _InputIterator2 __last2, + _OutputIterator __result, + _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + if (__comp(__first1, __first2)) + { + *__result = *__first1; + ++__first1; + ++__result; + } + else if (__comp(__first2, __first1)) + { + *__result = *__first2; + ++__first2; + ++__result; + } + else + { + ++__first1; + ++__first2; + } + return std::copy(__first2, __last2, + std::copy(__first1, __last1, __result)); + } +# 5369 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _OutputIterator + set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result) + { +# 5389 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + ; + ; + ; + ; + + return std::__set_symmetric_difference(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5419 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + inline _OutputIterator + set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, + _Compare __comp) + { +# 5440 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + ; + ; + ; + ; + + return std::__set_symmetric_difference(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + constexpr + _ForwardIterator + __min_element(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + if (__first == __last) + return __first; + _ForwardIterator __result = __first; + while (++__first != __last) + if (__comp(__first, __result)) + __result = __first; + return __result; + } +# 5472 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + constexpr + _ForwardIterator + inline min_element(_ForwardIterator __first, _ForwardIterator __last) + { + + + + + ; + ; + + return std::__min_element(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5497 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + constexpr + inline _ForwardIterator + min_element(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + + + + + + ; + ; + + return std::__min_element(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + constexpr + _ForwardIterator + __max_element(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + if (__first == __last) return __first; + _ForwardIterator __result = __first; + while (++__first != __last) + if (__comp(__result, __first)) + __result = __first; + return __result; + } +# 5536 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + constexpr + inline _ForwardIterator + max_element(_ForwardIterator __first, _ForwardIterator __last) + { + + + + + ; + ; + + return std::__max_element(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5561 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3 + template + constexpr + inline _ForwardIterator + max_element(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + + + + + + ; + ; + + return std::__max_element(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + +} +# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/algorithm" 2 3 +# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" 2 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/array" 1 3 +# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/array" 3 +# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/array" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + struct __array_traits + { + typedef _Tp _Type[_Nm]; + + static constexpr _Tp& + _S_ref(const _Type& __t, std::size_t __n) noexcept + { return const_cast<_Tp&>(__t[__n]); } + + static constexpr _Tp* + _S_ptr(const _Type& __t) noexcept + { return const_cast<_Tp*>(__t); } + }; + + template + struct __array_traits<_Tp, 0> + { + struct _Type { }; + + static constexpr _Tp& + _S_ref(const _Type&, std::size_t) noexcept + { return *static_cast<_Tp*>(nullptr); } + + static constexpr _Tp* + _S_ptr(const _Type&) noexcept + { return nullptr; } + }; +# 89 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/array" 3 + template + struct array + { + typedef _Tp value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef value_type* iterator; + typedef const value_type* const_iterator; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + + typedef std::__array_traits<_Tp, _Nm> _AT_Type; + typename _AT_Type::_Type _M_elems; + + + + + void + fill(const value_type& __u) + { std::fill_n(begin(), size(), __u); } + + void + swap(array& __other) + noexcept(__is_nothrow_swappable<_Tp>::value) + { std::swap_ranges(begin(), end(), __other.begin()); } + + + iterator + begin() noexcept + { return iterator(data()); } + + const_iterator + begin() const noexcept + { return const_iterator(data()); } + + iterator + end() noexcept + { return iterator(data() + _Nm); } + + const_iterator + end() const noexcept + { return const_iterator(data() + _Nm); } + + reverse_iterator + rbegin() noexcept + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const noexcept + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() noexcept + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const noexcept + { return const_reverse_iterator(begin()); } + + const_iterator + cbegin() const noexcept + { return const_iterator(data()); } + + const_iterator + cend() const noexcept + { return const_iterator(data() + _Nm); } + + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } + + + constexpr size_type + size() const noexcept { return _Nm; } + + constexpr size_type + max_size() const noexcept { return _Nm; } + + constexpr bool + empty() const noexcept { return size() == 0; } + + + reference + operator[](size_type __n) noexcept + { return _AT_Type::_S_ref(_M_elems, __n); } + + constexpr const_reference + operator[](size_type __n) const noexcept + { return _AT_Type::_S_ref(_M_elems, __n); } + + reference + at(size_type __n) + { + if (__n >= _Nm) + std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"), + + __n, _Nm); + return _AT_Type::_S_ref(_M_elems, __n); + } + + constexpr const_reference + at(size_type __n) const + { + + + return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n) + : (std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"), + + __n, _Nm), + _AT_Type::_S_ref(_M_elems, 0)); + } + + reference + front() noexcept + { return *begin(); } + + constexpr const_reference + front() const noexcept + { return _AT_Type::_S_ref(_M_elems, 0); } + + reference + back() noexcept + { return _Nm ? *(end() - 1) : *end(); } + + constexpr const_reference + back() const noexcept + { + return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1) + : _AT_Type::_S_ref(_M_elems, 0); + } + + pointer + data() noexcept + { return _AT_Type::_S_ptr(_M_elems); } + + const_pointer + data() const noexcept + { return _AT_Type::_S_ptr(_M_elems); } + }; + + + template + inline bool + operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return std::equal(__one.begin(), __one.end(), __two.begin()); } + + template + inline bool + operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return !(__one == __two); } + + template + inline bool + operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b) + { + return std::lexicographical_compare(__a.begin(), __a.end(), + __b.begin(), __b.end()); + } + + template + inline bool + operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return __two < __one; } + + template + inline bool + operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return !(__one > __two); } + + template + inline bool + operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return !(__one < __two); } + + + template + inline void + swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two) + noexcept(noexcept(__one.swap(__two))) + { __one.swap(__two); } + + template + constexpr _Tp& + get(array<_Tp, _Nm>& __arr) noexcept + { + static_assert(_Int < _Nm, "index is out of bounds"); + return std::__array_traits<_Tp, _Nm>:: + _S_ref(__arr._M_elems, _Int); + } + + template + constexpr _Tp&& + get(array<_Tp, _Nm>&& __arr) noexcept + { + static_assert(_Int < _Nm, "index is out of bounds"); + return std::move(std::get<_Int>(__arr)); + } + + template + constexpr const _Tp& + get(const array<_Tp, _Nm>& __arr) noexcept + { + static_assert(_Int < _Nm, "index is out of bounds"); + return std::__array_traits<_Tp, _Nm>:: + _S_ref(__arr._M_elems, _Int); + } + + +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + template + class tuple_size; + + + template + struct tuple_size> + : public integral_constant { }; + + + template + class tuple_element; + + + template + struct tuple_element<_Int, std::array<_Tp, _Nm>> + { + static_assert(_Int < _Nm, "index is out of bounds"); + typedef _Tp type; + }; + + template + struct __is_tuple_like_impl> : true_type + { }; + + +} +# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" 2 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstring" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstring" 3 +# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" 2 +# 63 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" +namespace mozilla { + + + + +template +inline constexpr T +narrow_cast(U&& u) +{ + return static_cast(mozilla::Forward(u)); +} +# 82 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" +constexpr const size_t dynamic_extent = mozilla::MaxValue::value; + +template +class Span; + + +namespace span_details { + +inline size_t strlen16(const char16_t* aZeroTerminated) { + size_t len = 0; + while (*(aZeroTerminated++)) { + len++; + } + return len; +} + + +template +using remove_cv_t = typename mozilla::RemoveCV::Type; +template +using remove_const_t = typename mozilla::RemoveConst::Type; +template +using conditional_t = typename mozilla::Conditional::Type; +template +using add_pointer_t = typename mozilla::AddPointer::Type; +template +using enable_if_t = typename mozilla::EnableIf::Type; + +template +struct is_span_oracle : mozilla::FalseType +{ +}; + +template +struct is_span_oracle> : mozilla::TrueType +{ +}; + +template +struct is_span : public is_span_oracle> +{ +}; + +template +struct is_std_array_oracle : mozilla::FalseType +{ +}; + +template +struct is_std_array_oracle> : mozilla::TrueType +{ +}; + +template +struct is_std_array : public is_std_array_oracle> +{ +}; + +template +struct is_allowed_extent_conversion + : public mozilla::IntegralConstant +{ +}; + +template +struct is_allowed_element_type_conversion + : public mozilla::IntegralConstant::value> +{ +}; + +template +class span_iterator +{ + using element_type_ = typename Span::element_type; + +public: + using iterator_category = std::random_access_iterator_tag; + using value_type = remove_const_t; + using difference_type = typename Span::index_type; + + using reference = conditional_t&; + using pointer = add_pointer_t; + + constexpr span_iterator() : span_iterator(nullptr, 0) {} + + span_iterator(const Span* span, + typename Span::index_type index) + : span_(span) + , index_(index) + { + do { static_assert(mozilla::detail::AssertionConditionType= 0 && index <= span_->Length()))>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span == nullptr || (index_ >= 0 && index <= span_->Length())))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span == nullptr || (index_ >= 0 && index <= span_->Length())" ")"); do { *((volatile int*) __null) = 176; ::abort(); } while (0); } } while (0); + + } + + friend class span_iterator; + constexpr span_iterator(const span_iterator& other) + : span_iterator(other.span_, other.index_) + { + } + + span_iterator& + operator=(const span_iterator&) = default; + + reference operator*() const + { + do { static_assert(mozilla::detail::AssertionConditionType::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span_))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span_" ")"); do { *((volatile int*) __null) = 190; ::abort(); } while (0); } } while (0); + return (*span_)[index_]; + } + + pointer operator->() const + { + do { static_assert(mozilla::detail::AssertionConditionType::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span_))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span_" ")"); do { *((volatile int*) __null) = 196; ::abort(); } while (0); } } while (0); + return &((*span_)[index_]); + } + + span_iterator& operator++() + { + do { static_assert(mozilla::detail::AssertionConditionType= 0 && index_ < span_->Length())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span_ && index_ >= 0 && index_ < span_->Length()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span_ && index_ >= 0 && index_ < span_->Length()" ")"); do { *((volatile int*) __null) = 202; ::abort(); } while (0); } } while (0); + ++index_; + return *this; + } + + span_iterator operator++(int) + { + auto ret = *this; + ++(*this); + return ret; + } + + span_iterator& operator--() + { + do { static_assert(mozilla::detail::AssertionConditionType 0 && index_ <= span_->Length())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span_ && index_ > 0 && index_ <= span_->Length()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span_ && index_ > 0 && index_ <= span_->Length()" ")"); do { *((volatile int*) __null) = 216; ::abort(); } while (0); } } while (0); + --index_; + return *this; + } + + span_iterator operator--(int) + { + auto ret = *this; + --(*this); + return ret; + } + + span_iterator + operator+(difference_type n) const + { + auto ret = *this; + return ret += n; + } + + span_iterator& operator+=(difference_type n) + { + do { static_assert(mozilla::detail::AssertionConditionType= 0 && (index_ + n) <= span_->Length())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span_ && (index_ + n) >= 0 && (index_ + n) <= span_->Length()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span_ && (index_ + n) >= 0 && (index_ + n) <= span_->Length()" ")"); do { *((volatile int*) __null) = 238; ::abort(); } while (0); } } while (0); + + index_ += n; + return *this; + } + + span_iterator + operator-(difference_type n) const + { + auto ret = *this; + return ret -= n; + } + + span_iterator& operator-=(difference_type n) + + { + return *this += -n; + } + + difference_type + operator-(const span_iterator& rhs) const + { + do { static_assert(mozilla::detail::AssertionConditionType::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span_ == rhs.span_))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span_ == rhs.span_" ")"); do { *((volatile int*) __null) = 259; ::abort(); } while (0); } } while (0); + return index_ - rhs.index_; + } + + constexpr reference operator[](difference_type n) const + { + return *(*this + n); + } + + constexpr friend bool operator==(const span_iterator& lhs, + const span_iterator& rhs) + { + return lhs.span_ == rhs.span_ && lhs.index_ == rhs.index_; + } + + constexpr friend bool operator!=(const span_iterator& lhs, + const span_iterator& rhs) + { + return !(lhs == rhs); + } + + friend bool operator<(const span_iterator& lhs, + const span_iterator& rhs) + { + do { static_assert(mozilla::detail::AssertionConditionType::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(lhs.span_ == rhs.span_))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "lhs.span_ == rhs.span_" ")"); do { *((volatile int*) __null) = 283; ::abort(); } while (0); } } while (0); + return lhs.index_ < rhs.index_; + } + + constexpr friend bool operator<=(const span_iterator& lhs, + const span_iterator& rhs) + { + return !(rhs < lhs); + } + + constexpr friend bool operator>(const span_iterator& lhs, + const span_iterator& rhs) + { + return rhs < lhs; + } + + constexpr friend bool operator>=(const span_iterator& lhs, + const span_iterator& rhs) + { + return !(rhs > lhs); + } + + void swap(span_iterator& rhs) + { + std::swap(index_, rhs.index_); + std::swap(span_, rhs.span_); + } + +protected: + const Span* span_; + size_t index_; +}; + +template +inline constexpr span_iterator +operator+(typename span_iterator::difference_type n, + const span_iterator& rhs) +{ + return rhs + n; +} + +template +class extent_type +{ +public: + using index_type = size_t; + + static_assert(Ext >= 0, "A fixed-size Span must be >= 0 in size."); + + constexpr extent_type() {} + + template + extent_type(extent_type ext) + { + static_assert( + Other == Ext || Other == dynamic_extent, + "Mismatch between fixed-size extent and size of initializing data."); + do { static_assert(mozilla::detail::AssertionConditionType::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(ext.size() == Ext))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "ext.size() == Ext" ")"); do { *((volatile int*) __null) = 340; ::abort(); } while (0); } } while (0); + } + + extent_type(index_type length) + { + do { static_assert(mozilla::detail::AssertionConditionType::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(length == Ext))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "length == Ext" ")"); do { *((volatile int*) __null) = 345; ::abort(); } while (0); } } while (0); + } + + constexpr index_type size() const { return Ext; } +}; + +template<> +class extent_type +{ +public: + using index_type = size_t; + + template + explicit constexpr extent_type(extent_type ext) + : size_(ext.size()) + { + } + + explicit constexpr extent_type(index_type length) + : size_(length) + { + } + + constexpr index_type size() const { return size_; } + +private: + index_type size_; +}; +} +# 436 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" +template +class Span +{ +public: + + using element_type = ElementType; + using index_type = size_t; + using pointer = element_type*; + using reference = element_type&; + + using iterator = + span_details::span_iterator, false>; + using const_iterator = + span_details::span_iterator, true>; + using reverse_iterator = std::reverse_iterator; + using const_reverse_iterator = std::reverse_iterator; + + constexpr static const index_type extent = Extent; + + + + + + + + template< + bool Dependent = false, + class = span_details::enable_if_t< + (Dependent || Extent == 0 || Extent == mozilla::MaxValue::value)>> + constexpr Span() + : storage_(nullptr, span_details::extent_type<0>()) + { + } + + + + + constexpr Span(std::nullptr_t) : Span() {} + + + + + constexpr Span(pointer aPtr, index_type aLength) + : storage_(aPtr, aLength) + { + } + + + + + constexpr Span(pointer aStartPtr, pointer aEndPtr) + : storage_(aStartPtr, std::distance(aStartPtr, aEndPtr)) + { + } + + + + + template + constexpr Span(element_type (&aArr)[N]) + : storage_(&aArr[0], span_details::extent_type()) + { + } + + + + + template> + constexpr Span(std::array& aArr) + : storage_(&aArr[0], span_details::extent_type()) + { + } + + + + + template + constexpr Span( + const std::array, N>& aArr) + : storage_(&aArr[0], span_details::extent_type()) + { + } + + + + + template> + constexpr Span(mozilla::Array& aArr) + : storage_(&aArr[0], span_details::extent_type()) + { + } + + + + + template + constexpr Span( + const mozilla::Array, N>& aArr) + : storage_(&aArr[0], span_details::extent_type()) + { + } + + + + + template> + constexpr Span(const mozilla::UniquePtr& aPtr, + index_type aLength) + : storage_(aPtr.get(), aLength) + { + } + + + + + + + template< + class Container, + class = span_details::enable_if_t< + !span_details::is_span::value && + !span_details::is_std_array::value && + mozilla::IsConvertible::value && + mozilla::IsConvertible().data())>::value>> + constexpr Span(Container& cont) + : Span(cont.data(), ReleaseAssertedCast(cont.size())) + { + } + + + + + template< + class Container, + class = span_details::enable_if_t< + mozilla::IsConst::value && + !span_details::is_span::value && + mozilla::IsConvertible::value && + mozilla::IsConvertible().data())>::value>> + constexpr Span(const Container& cont) + : Span(cont.data(), ReleaseAssertedCast(cont.size())) + { + } + + + + + constexpr Span(const Span& other) = default; + + + + + constexpr Span(Span&& other) = default; + + + + + template< + class OtherElementType, + size_t OtherExtent, + class = span_details::enable_if_t< + span_details::is_allowed_extent_conversion::value && + span_details::is_allowed_element_type_conversion::value>> + constexpr Span(const Span& other) + : storage_(other.data(), + span_details::extent_type(other.size())) + { + } + + + + + template< + class OtherElementType, + size_t OtherExtent, + class = span_details::enable_if_t< + span_details::is_allowed_extent_conversion::value && + span_details::is_allowed_element_type_conversion::value>> + constexpr Span(Span&& other) + : storage_(other.data(), + span_details::extent_type(other.size())) + { + } + + ~Span() = default; + Span& operator=(const Span& other) + = default; + + Span& operator=(Span&& other) + = default; + + + + + + template + Span First() const + { + do { static_assert(mozilla::detail::AssertionConditionType::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(Count <= size()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "Count <= size()" ")"); do { *((volatile int*) __null) = 640; ::abort(); } while (0); } } while (0); + return { data(), Count }; + } + + + + + template + Span Last() const + { + do { static_assert(mozilla::detail::AssertionConditionType::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(Count <= size()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "Count <= size()" ")"); do { *((volatile int*) __null) = 650; ::abort(); } while (0); } } while (0); + return { data() + (size() - Count), Count }; + } + + + + + template + Span Subspan() const + { + do { static_assert(mozilla::detail::AssertionConditionType::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(Offset <= size() && (Count == dynamic_extent || (Offset + Count <= size()))))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "Offset <= size() && (Count == dynamic_extent || (Offset + Count <= size()))" ")"); do { *((volatile int*) __null) = 661; ::abort(); } while (0); } } while (0); + + return { data() + Offset, + Count == dynamic_extent ? size() - Offset : Count }; + } + + + + + Span First( + index_type aCount) const + { + do { static_assert(mozilla::detail::AssertionConditionType::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aCount <= size()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aCount <= size()" ")"); do { *((volatile int*) __null) = 672; ::abort(); } while (0); } } while (0); + return { data(), aCount }; + } + + + + + Span Last( + index_type aCount) const + { + do { static_assert(mozilla::detail::AssertionConditionType::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aCount <= size()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aCount <= size()" ")"); do { *((volatile int*) __null) = 682; ::abort(); } while (0); } } while (0); + return { data() + (size() - aCount), aCount }; + } + + + + + Span Subspan( + index_type aStart, + index_type aLength = dynamic_extent) const + { + do { static_assert(mozilla::detail::AssertionConditionType::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aStart <= size() && (aLength == dynamic_extent || (aStart + aLength <= size()))))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aStart <= size() && (aLength == dynamic_extent || (aStart + aLength <= size()))" ")"); do { *((volatile int*) __null) = 695; ::abort(); } while (0); } } while (0); + + + return { data() + aStart, + aLength == dynamic_extent ? size() - aStart : aLength }; + } + + + + + Span From( + index_type aStart) const + { + return Subspan(aStart); + } + + + + + Span To( + index_type aEnd) const + { + return Subspan(0, aEnd); + } + + + + + + Span FromTo( + index_type aStart, + index_type aEnd) const + { + do { static_assert(mozilla::detail::AssertionConditionType::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aStart <= aEnd))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aStart <= aEnd" ")"); do { *((volatile int*) __null) = 726; ::abort(); } while (0); } } while (0); + return Subspan(aStart, aEnd - aStart); + } + + + + + + constexpr index_type Length() const { return size(); } + + + + + constexpr index_type size() const { return storage_.size(); } + + + + + constexpr index_type LengthBytes() const { return size_bytes(); } + + + + + constexpr index_type size_bytes() const + { + return size() * narrow_cast(sizeof(element_type)); + } + + + + + constexpr bool IsEmpty() const { return empty(); } + + + + + + constexpr bool empty() const { return size() == 0; } + + + reference operator[](index_type idx) const + { + do { static_assert(mozilla::detail::AssertionConditionType::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(idx < storage_.size()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "idx < storage_.size()" ")"); do { *((volatile int*) __null) = 768; ::abort(); } while (0); } } while (0); + return data()[idx]; + } + + + + + constexpr reference at(index_type idx) const { return this->operator[](idx); } + + constexpr reference operator()(index_type idx) const + { + return this->operator[](idx); + } + + + + + constexpr pointer Elements() const { return data(); } + + + + + constexpr pointer data() const { return storage_.data(); } + + + iterator begin() const { return { this, 0 }; } + iterator end() const { return { this, Length() }; } + + const_iterator cbegin() const { return { this, 0 }; } + const_iterator cend() const { return { this, Length() }; } + + reverse_iterator rbegin() const + { + return reverse_iterator{ end() }; + } + reverse_iterator rend() const + { + return reverse_iterator{ begin() }; + } + + const_reverse_iterator crbegin() const + { + return const_reverse_iterator{ cend() }; + } + const_reverse_iterator crend() const + { + return const_reverse_iterator{ cbegin() }; + } + +private: + + + + template + class storage_type : public ExtentType + { + public: + template + storage_type(pointer elements, + OtherExtentType ext) + : ExtentType(ext) + , data_(elements) + { + do { static_assert(mozilla::detail::AssertionConditionType::value))>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!((!elements && ExtentType::size() == 0) || (elements && ExtentType::size() != mozilla::MaxValue::value)))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "(!elements && ExtentType::size() == 0) || (elements && ExtentType::size() != mozilla::MaxValue::value)" ")"); do { *((volatile int*) __null) = 833; ::abort(); } while (0); } } while (0); + + + } + + constexpr pointer data() const { return data_; } + + private: + pointer data_; + }; + + storage_type> storage_; +}; + + +template +inline constexpr bool +operator==(const Span& l, + const Span& r) +{ + return (l.size() == r.size()) && std::equal(l.begin(), l.end(), r.begin()); +} + +template +inline constexpr bool +operator!=(const Span& l, + const Span& r) +{ + return !(l == r); +} + +template +inline constexpr bool +operator<(const Span& l, + const Span& r) +{ + return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end()); +} + +template +inline constexpr bool +operator<=(const Span& l, + const Span& r) +{ + return !(l > r); +} + +template +inline constexpr bool +operator>(const Span& l, + const Span& r) +{ + return r < l; +} + +template +inline constexpr bool +operator>=(const Span& l, + const Span& r) +{ + return !(l < r); +} + +namespace span_details { + + + + + + +template +struct calculate_byte_size + : mozilla::IntegralConstant(sizeof(ElementType) * + static_cast(Extent))> +{ +}; + +template +struct calculate_byte_size + : mozilla::IntegralConstant +{ +}; +} + + + + + +template +Span::value> +AsBytes(Span s) +{ + return { reinterpret_cast(s.data()), s.size_bytes() }; +} + + + + +template::value>> +Span::value> +AsWritableBytes(Span s) +{ + return { reinterpret_cast(s.data()), s.size_bytes() }; +} + + + + + + + +template +Span +MakeSpan(ElementType* aPtr, typename Span::index_type aLength) +{ + return Span(aPtr, aLength); +} + + + + +template +Span +MakeSpan(ElementType* aStartPtr, ElementType* aEndPtr) +{ + return Span(aStartPtr, aEndPtr); +} + + + + +template +Span MakeSpan(ElementType (&aArr)[N]) +{ + return Span(aArr); +} + + + + +template +Span +MakeSpan(mozilla::Array& aArr) +{ + return aArr; +} + + + + +template +Span +MakeSpan(const mozilla::Array& arr) +{ + return arr; +} + + + + +template +Span +MakeSpan(Container& cont) +{ + return Span(cont); +} + + + + +template +Span +MakeSpan(const Container& cont) +{ + return Span(cont); +} + + + + +template +Span +MakeSpan(Ptr& aPtr, size_t aLength) +{ + return Span(aPtr, aLength); +} + + + + +inline Span +MakeStringSpan(const char* aZeroTerminated) +{ + return Span(aZeroTerminated, std::strlen(aZeroTerminated)); +} + + + + +inline Span +MakeStringSpan(const char16_t* aZeroTerminated) +{ + return Span(aZeroTerminated, span_details::strlen16(aZeroTerminated)); +} + +} +# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2 + + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionNoteChild.h" 1 +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionNoteChild.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionTraversalCallback.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionTraversalCallback.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 1 +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EnumeratedArray.h" 1 +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EnumeratedArray.h" +namespace mozilla { +# 41 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EnumeratedArray.h" +template +class EnumeratedArray +{ +public: + static const size_t kSize = size_t(SizeAsEnumValue); + +private: + typedef Array ArrayType; + + ArrayType mArray; + +public: + EnumeratedArray() {} + + template + EnumeratedArray(Args&&... aArgs) + : mArray{mozilla::Forward(aArgs)...} + {} + + explicit EnumeratedArray(const EnumeratedArray& aOther) + { + for (size_t i = 0; i < kSize; i++) { + mArray[i] = aOther.mArray[i]; + } + } + + EnumeratedArray(EnumeratedArray&& aOther) + { + for (size_t i = 0; i < kSize; i++) { + mArray[i] = Move(aOther.mArray[i]); + } + } + + ValueType& operator[](IndexType aIndex) + { + return mArray[size_t(aIndex)]; + } + + const ValueType& operator[](IndexType aIndex) const + { + return mArray[size_t(aIndex)]; + } + + typedef typename ArrayType::iterator iterator; + typedef typename ArrayType::const_iterator const_iterator; + typedef typename ArrayType::reverse_iterator reverse_iterator; + typedef typename ArrayType::const_reverse_iterator const_reverse_iterator; + + + iterator begin() { return mArray.begin(); } + const_iterator begin() const { return mArray.begin(); } + const_iterator cbegin() const { return mArray.cbegin(); } + iterator end() { return mArray.end(); } + const_iterator end() const { return mArray.end(); } + const_iterator cend() const { return mArray.cend(); } + + + reverse_iterator rbegin() { return mArray.rbegin(); } + const_reverse_iterator rbegin() const { return mArray.rbegin(); } + const_reverse_iterator crbegin() const { return mArray.crbegin(); } + reverse_iterator rend() { return mArray.rend(); } + const_reverse_iterator rend() const { return mArray.rend(); } + const_reverse_iterator crend() const { return mArray.crend(); } +}; + +} +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h" 1 +# 75 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h" +namespace mozilla { + +template +class LinkedListElement; + +namespace detail { + + + + + + +template +struct LinkedListElementTraits +{ + typedef T* RawType; + typedef const T* ConstRawType; + typedef T* ClientType; + typedef const T* ConstClientType; + + + + + + + static void enterList(LinkedListElement* elt) {} + static void exitList(LinkedListElement* elt) {} +}; + +template +struct LinkedListElementTraits> +{ + typedef T* RawType; + typedef const T* ConstRawType; + typedef RefPtr ClientType; + typedef RefPtr ConstClientType; + + static void enterList(LinkedListElement>* elt) { elt->asT()->AddRef(); } + static void exitList(LinkedListElement>* elt) { elt->asT()->Release(); } +}; + +} + +template +class LinkedList; + +template +class LinkedListElement +{ + typedef typename detail::LinkedListElementTraits Traits; + typedef typename Traits::RawType RawType; + typedef typename Traits::ConstRawType ConstRawType; + typedef typename Traits::ClientType ClientType; + typedef typename Traits::ConstClientType ConstClientType; +# 164 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h" +private: + LinkedListElement* mNext; + LinkedListElement* mPrev; + const bool mIsSentinel; + +public: + LinkedListElement() + : mNext(this), + mPrev(this), + mIsSentinel(false) + { } + + + + + + LinkedListElement(LinkedListElement&& aOther) + : mIsSentinel(aOther.mIsSentinel) + { + adjustLinkForMove(Move(aOther)); + } + + LinkedListElement& operator=(LinkedListElement&& aOther) + { + do { } while (0); + do { } while (0); + + adjustLinkForMove(Move(aOther)); + return *this; + } + + ~LinkedListElement() + { + if (!mIsSentinel && isInList()) { + remove(); + } + } + + + + + + RawType getNext() { return mNext->asT(); } + ConstRawType getNext() const { return mNext->asT(); } + + + + + + RawType getPrevious() { return mPrev->asT(); } + ConstRawType getPrevious() const { return mPrev->asT(); } + + + + + + void setNext(RawType aElem) + { + do { } while (0); + setNextUnsafe(aElem); + } + + + + + + + void setPrevious(RawType aElem) + { + do { } while (0); + setPreviousUnsafe(aElem); + } + + + + + + void remove() + { + do { } while (0); + + mPrev->mNext = mNext; + mNext->mPrev = mPrev; + mNext = this; + mPrev = this; + + Traits::exitList(this); + } + + + + + + + ClientType removeAndGetNext() + { + ClientType r = getNext(); + remove(); + return r; + } + + + + + + + ClientType removeAndGetPrevious() + { + ClientType r = getPrevious(); + remove(); + return r; + } + + + + + + void removeFrom(const LinkedList& aList) + { + aList.assertContains(asT()); + remove(); + } + + + + + bool isInList() const + { + do { } while (0); + return mNext != this; + } + +private: + friend class LinkedList; + friend struct detail::LinkedListElementTraits; + + enum class NodeKind { + Normal, + Sentinel + }; + + explicit LinkedListElement(NodeKind nodeKind) + : mNext(this), + mPrev(this), + mIsSentinel(nodeKind == NodeKind::Sentinel) + { } + + + + + + RawType asT() + { + return mIsSentinel ? nullptr : static_cast(this); + } + ConstRawType asT() const + { + return mIsSentinel ? nullptr : static_cast(this); + } + + + + + + void setNextUnsafe(RawType aElem) + { + LinkedListElement *listElem = static_cast(aElem); + do { } while (0); + + listElem->mNext = this->mNext; + listElem->mPrev = this; + this->mNext->mPrev = listElem; + this->mNext = listElem; + + Traits::enterList(aElem); + } + + + + + + void setPreviousUnsafe(RawType aElem) + { + LinkedListElement* listElem = static_cast*>(aElem); + do { } while (0); + + listElem->mNext = this; + listElem->mPrev = this->mPrev; + this->mPrev->mNext = listElem; + this->mPrev = listElem; + + Traits::enterList(aElem); + } + + + + + + void adjustLinkForMove(LinkedListElement&& aOther) + { + if (!aOther.isInList()) { + mNext = this; + mPrev = this; + return; + } + + if (!mIsSentinel) { + Traits::enterList(this); + } + + do { } while (0); + do { } while (0); + + + + + + mNext = aOther.mNext; + mPrev = aOther.mPrev; + + mNext->mPrev = this; + mPrev->mNext = this; + + + + + + aOther.mNext = &aOther; + aOther.mPrev = &aOther; + + if (!mIsSentinel) { + Traits::exitList(&aOther); + } + } + + LinkedListElement& operator=(const LinkedListElement& aOther) = delete; + LinkedListElement(const LinkedListElement& aOther) = delete; +}; + +template +class LinkedList +{ +private: + typedef typename detail::LinkedListElementTraits Traits; + typedef typename Traits::RawType RawType; + typedef typename Traits::ConstRawType ConstRawType; + typedef typename Traits::ClientType ClientType; + typedef typename Traits::ConstClientType ConstClientType; + + LinkedListElement sentinel; + +public: + class Iterator { + RawType mCurrent; + + public: + explicit Iterator(RawType aCurrent) : mCurrent(aCurrent) {} + + RawType operator *() const { + return mCurrent; + } + + const Iterator& operator++() { + mCurrent = mCurrent->getNext(); + return *this; + } + + bool operator!=(Iterator& aOther) const { + return mCurrent != aOther.mCurrent; + } + }; + + LinkedList() : sentinel(LinkedListElement::NodeKind::Sentinel) { } + + LinkedList(LinkedList&& aOther) + : sentinel(mozilla::Move(aOther.sentinel)) + { } + + LinkedList& operator=(LinkedList&& aOther) + { + do { } while (0); + sentinel = mozilla::Move(aOther.sentinel); + return *this; + } + + ~LinkedList() { + do { } while (0); + + + + } + + + + + void insertFront(RawType aElem) + { + + sentinel.setNextUnsafe(aElem); + } + + + + + void insertBack(RawType aElem) + { + sentinel.setPreviousUnsafe(aElem); + } + + + + + RawType getFirst() { return sentinel.getNext(); } + ConstRawType getFirst() const { return sentinel.getNext(); } + + + + + RawType getLast() { return sentinel.getPrevious(); } + ConstRawType getLast() const { return sentinel.getPrevious(); } + + + + + + ClientType popFirst() + { + ClientType ret = sentinel.getNext(); + if (ret) { + static_cast*>(RawType(ret))->remove(); + } + return ret; + } + + + + + + ClientType popLast() + { + ClientType ret = sentinel.getPrevious(); + if (ret) { + static_cast*>(RawType(ret))->remove(); + } + return ret; + } + + + + + bool isEmpty() const + { + return !sentinel.isInList(); + } + + + + + + + + void clear() + { + while (popFirst()) { + continue; + } + } + + + + + + + Iterator begin() { + return Iterator(getFirst()); + } + Iterator end() { + return Iterator(nullptr); + } + + + + + + + + size_t sizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const + { + size_t n = 0; + for (const T* t = getFirst(); t; t = t->getNext()) { + n += aMallocSizeOf(t); + } + return n; + } + + + + + size_t sizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const + { + return aMallocSizeOf(this) + sizeOfExcludingThis(aMallocSizeOf); + } + + + + + + void debugAssertIsSane() const + { +# 622 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h" + } + +private: + friend class LinkedListElement; + + void assertContains(const RawType aValue) const + { +# 637 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h" + } + + LinkedList& operator=(const LinkedList& aOther) = delete; + LinkedList(const LinkedList& aOther) = delete; +}; + +template +class AutoCleanLinkedList : public LinkedList +{ +public: + ~AutoCleanLinkedList() + { + while (T* element = this->popFirst()) { + delete element; + } + } +}; + +} +# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PodOperations.h" 1 +# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PodOperations.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayUtils.h" 1 +# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayUtils.h" +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 +# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayUtils.h" 2 + + + + + + + + +namespace mozilla { +# 40 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayUtils.h" +template +__attribute__((always_inline)) inline size_t +PointerRangeSize(T* aBegin, T* aEnd) +{ + do { } while (0); + return (size_t(aEnd) - size_t(aBegin)) / sizeof(T); +} + + + + + + + +template +constexpr size_t +ArrayLength(T (&aArr)[N]) +{ + return N; +} + +template +constexpr size_t +ArrayLength(const Array& aArr) +{ + return N; +} + +template +constexpr size_t +ArrayLength(const EnumeratedArray& aArr) +{ + return size_t(N); +} + + + + + + +template +constexpr T* +ArrayEnd(T (&aArr)[N]) +{ + return aArr + ArrayLength(aArr); +} + +template +constexpr T* +ArrayEnd(Array& aArr) +{ + return &aArr[0] + ArrayLength(aArr); +} + +template +constexpr const T* +ArrayEnd(const Array& aArr) +{ + return &aArr[0] + ArrayLength(aArr); +} + +namespace detail { + +template::value>> +struct AlignedChecker +{ + static void + test(const Pointee* aPtr) + { + do { } while (0); + + } +}; + +template +struct AlignedChecker +{ + static void + test(const Pointee* aPtr) + { + } +}; + +} +# 139 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayUtils.h" +template +inline typename EnableIf::value || + IsBaseOf::value || + IsVoid::value, + bool>::Type +IsInRange(const T* aPtr, const U* aBegin, const U* aEnd) +{ + do { } while (0); + detail::AlignedChecker::test(aPtr); + detail::AlignedChecker::test(aBegin); + detail::AlignedChecker::test(aEnd); + return aBegin <= reinterpret_cast(aPtr) && + reinterpret_cast(aPtr) < aEnd; +} + + + + + + +template +inline bool +IsInRange(const T* aPtr, uintptr_t aBegin, uintptr_t aEnd) +{ + return IsInRange(aPtr, + reinterpret_cast(aBegin), + reinterpret_cast(aEnd)); +} + +namespace detail { + + + + + +template +char (&ArrayLengthHelper(T (&array)[N]))[N]; + +} + +} +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PodOperations.h" 2 + + + + + +namespace mozilla { + + +template +static __attribute__((always_inline)) inline void +PodZero(T* aT) +{ + memset(aT, 0, sizeof(T)); +} + + +template +static __attribute__((always_inline)) inline void +PodZero(T* aT, size_t aNElem) +{ + + + + + + for (T* end = aT + aNElem; aT < end; aT++) { + memset(aT, 0, sizeof(T)); + } +} +# 57 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PodOperations.h" +template +static void PodZero(T (&aT)[N]) = delete; +template +static void PodZero(T (&aT)[N], size_t aNElem) = delete; + + +template +static __attribute__((always_inline)) inline void +PodArrayZero(T (&aT)[N]) +{ + memset(aT, 0, N * sizeof(T)); +} + +template +static __attribute__((always_inline)) inline void +PodArrayZero(Array& aArr) +{ + memset(&aArr[0], 0, N * sizeof(T)); +} + + + + + +template +static __attribute__((always_inline)) inline void +PodAssign(T* aDst, const T* aSrc) +{ + do { } while (0); + + memcpy(reinterpret_cast(aDst), reinterpret_cast(aSrc), + sizeof(T)); +} + + + + + +template +static __attribute__((always_inline)) inline void +PodCopy(T* aDst, const T* aSrc, size_t aNElem) +{ + do { } while (0); + + if (aNElem < 128) { + + + + + for (const T* srcend = aSrc + aNElem; aSrc < srcend; aSrc++, aDst++) { + PodAssign(aDst, aSrc); + } + } else { + memcpy(aDst, aSrc, aNElem * sizeof(T)); + } +} + +template +static __attribute__((always_inline)) inline void +PodCopy(volatile T* aDst, const volatile T* aSrc, size_t aNElem) +{ + do { } while (0); +# 127 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PodOperations.h" + for (const volatile T* srcend = aSrc + aNElem; + aSrc < srcend; + aSrc++, aDst++) { + *aDst = *aSrc; + } +} + + + + + +template +static __attribute__((always_inline)) inline void +PodArrayCopy(T (&aDst)[N], const T (&aSrc)[N]) +{ + PodCopy(aDst, aSrc, N); +} + + + + + + + +template +static __attribute__((always_inline)) inline void +PodMove(T* aDst, const T* aSrc, size_t aNElem) +{ + do { } while (0); + + memmove(aDst, aSrc, aNElem * sizeof(T)); +} + + + + + +template +static __attribute__((always_inline)) inline bool +PodEqual(const T* one, const T* two, size_t len) +{ + if (len < 128) { + const T* p1end = one + len; + const T* p1 = one; + const T* p2 = two; + for (; p1 < p1end; p1++, p2++) { + if (*p1 != *p2) { + return false; + } + } + return true; + } + + return !memcmp(one, two, len * sizeof(T)); +} + + + + + +template +static __attribute__((always_inline)) inline bool +PodEqual(const T (&one)[N], const T (&two)[N]) +{ + return PodEqual(one, two, N); +} + +} +# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2 + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsprototypes.h" 1 +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jstypes.h" 1 +# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jstypes.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js-config.h" 1 +# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jstypes.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsversion.h" 1 +# 36 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jstypes.h" 2 +# 139 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jstypes.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jscpucfg.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jscpucfg.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h" 1 +# 70 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/DebugOnly.h" 1 +# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/DebugOnly.h" +namespace mozilla { +# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/DebugOnly.h" +template +class DebugOnly +{ +public: +# 69 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/DebugOnly.h" + DebugOnly() { } + DebugOnly(const T&) { } + DebugOnly(const DebugOnly&) { } + DebugOnly& operator=(const T&) { return *this; } + void operator++(int) { } + void operator--(int) { } + DebugOnly& operator+=(const T&) { return *this; } + DebugOnly& operator-=(const T&) { return *this; } + DebugOnly& operator&=(const T&) { return *this; } + DebugOnly& operator|=(const T&) { return *this; } + DebugOnly& operator^=(const T&) { return *this; } + + + + + + + + ~DebugOnly() {} +}; + +} +# 71 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h" 2 +# 158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h" +namespace mozilla { + +namespace detail { + + + + + + +template +struct Swapper; + +template +struct Swapper +{ + static T swap(T aValue) + { + + return __builtin_bswap16(aValue); + + + + } +}; + +template +struct Swapper +{ + static T swap(T aValue) + { + + return T(__builtin_bswap32(aValue)); +# 198 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h" + } +}; + +template +struct Swapper +{ + static inline T swap(T aValue) + { + + return T(__builtin_bswap64(aValue)); +# 220 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h" + } +}; + +enum Endianness { Little, Big }; + + + + + + + +class EndianUtils +{ + + + + + static void assertNoOverlap(const void* aDest, const void* aSrc, + size_t aCount) + { + DebugOnly byteDestPtr = static_cast(aDest); + DebugOnly byteSrcPtr = static_cast(aSrc); + do { } while (0); + + + + } + + template + static void assertAligned(T* aPtr) + { + do { } while (0); + } + +protected: + + + + + template + static inline T maybeSwap(T aValue) + { + if (SourceEndian == DestEndian) { + return aValue; + } + return Swapper::swap(aValue); + } + + + + + + template + static inline void maybeSwapInPlace(T* aPtr, size_t aCount) + { + assertAligned(aPtr); + + if (SourceEndian == DestEndian) { + return; + } + for (size_t i = 0; i < aCount; i++) { + aPtr[i] = Swapper::swap(aPtr[i]); + } + } + + + + + + template + static void copyAndSwapTo(void* aDest, const T* aSrc, size_t aCount) + { + assertNoOverlap(aDest, aSrc, aCount * sizeof(T)); + assertAligned(aSrc); + + if (SourceEndian == DestEndian) { + memcpy(aDest, aSrc, aCount * sizeof(T)); + return; + } + + uint8_t* byteDestPtr = static_cast(aDest); + for (size_t i = 0; i < aCount; ++i) { + union + { + T mVal; + uint8_t mBuffer[sizeof(T)]; + } u; + u.mVal = maybeSwap(aSrc[i]); + memcpy(byteDestPtr, u.mBuffer, sizeof(T)); + byteDestPtr += sizeof(T); + } + } + + + + + + template + static void copyAndSwapFrom(T* aDest, const void* aSrc, size_t aCount) + { + assertNoOverlap(aDest, aSrc, aCount * sizeof(T)); + assertAligned(aDest); + + if (SourceEndian == DestEndian) { + memcpy(aDest, aSrc, aCount * sizeof(T)); + return; + } + + const uint8_t* byteSrcPtr = static_cast(aSrc); + for (size_t i = 0; i < aCount; ++i) { + union + { + T mVal; + uint8_t mBuffer[sizeof(T)]; + } u; + memcpy(u.mBuffer, byteSrcPtr, sizeof(T)); + aDest[i] = maybeSwap(u.mVal); + byteSrcPtr += sizeof(T); + } + } +}; + +template +class Endian : private EndianUtils +{ +protected: + + static __attribute__ ((warn_unused_result)) uint16_t readUint16(const void* aPtr) + { + return read(aPtr); + } + + + static __attribute__ ((warn_unused_result)) uint32_t readUint32(const void* aPtr) + { + return read(aPtr); + } + + + static __attribute__ ((warn_unused_result)) uint64_t readUint64(const void* aPtr) + { + return read(aPtr); + } + + + static __attribute__ ((warn_unused_result)) int16_t readInt16(const void* aPtr) + { + return read(aPtr); + } + + + static __attribute__ ((warn_unused_result)) int32_t readInt32(const void* aPtr) + { + return read(aPtr); + } + + + static __attribute__ ((warn_unused_result)) int64_t readInt64(const void* aPtr) + { + return read(aPtr); + } + + + static void writeUint16(void* aPtr, uint16_t aValue) + { + write(aPtr, aValue); + } + + + static void writeUint32(void* aPtr, uint32_t aValue) + { + write(aPtr, aValue); + } + + + static void writeUint64(void* aPtr, uint64_t aValue) + { + write(aPtr, aValue); + } + + + static void writeInt16(void* aPtr, int16_t aValue) + { + write(aPtr, aValue); + } + + + static void writeInt32(void* aPtr, int32_t aValue) + { + write(aPtr, aValue); + } + + + static void writeInt64(void* aPtr, int64_t aValue) + { + write(aPtr, aValue); + } +# 425 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h" + template + __attribute__ ((warn_unused_result)) static T swapToLittleEndian(T aValue) + { + return maybeSwap(aValue); + } + + + + + + + template + static void copyAndSwapToLittleEndian(void* aDest, const T* aSrc, + size_t aCount) + { + copyAndSwapTo(aDest, aSrc, aCount); + } + + + + + template + static void swapToLittleEndianInPlace(T* aPtr, size_t aCount) + { + maybeSwapInPlace(aPtr, aCount); + } + + + + + template + __attribute__ ((warn_unused_result)) static T swapToBigEndian(T aValue) + { + return maybeSwap(aValue); + } + + + + + + + template + static void copyAndSwapToBigEndian(void* aDest, const T* aSrc, + size_t aCount) + { + copyAndSwapTo(aDest, aSrc, aCount); + } + + + + + template + static void swapToBigEndianInPlace(T* aPtr, size_t aCount) + { + maybeSwapInPlace(aPtr, aCount); + } + + + + + + + template + __attribute__ ((warn_unused_result)) static T swapToNetworkOrder(T aValue) + { + return swapToBigEndian(aValue); + } + + template + static void + copyAndSwapToNetworkOrder(void* aDest, const T* aSrc, size_t aCount) + { + copyAndSwapToBigEndian(aDest, aSrc, aCount); + } + + template + static void + swapToNetworkOrderInPlace(T* aPtr, size_t aCount) + { + swapToBigEndianInPlace(aPtr, aCount); + } + + + + + template + __attribute__ ((warn_unused_result)) static T swapFromLittleEndian(T aValue) + { + return maybeSwap(aValue); + } + + + + + + + template + static void copyAndSwapFromLittleEndian(T* aDest, const void* aSrc, + size_t aCount) + { + copyAndSwapFrom(aDest, aSrc, aCount); + } + + + + + template + static void swapFromLittleEndianInPlace(T* aPtr, size_t aCount) + { + maybeSwapInPlace(aPtr, aCount); + } + + + + + template + __attribute__ ((warn_unused_result)) static T swapFromBigEndian(T aValue) + { + return maybeSwap(aValue); + } + + + + + + + template + static void copyAndSwapFromBigEndian(T* aDest, const void* aSrc, + size_t aCount) + { + copyAndSwapFrom(aDest, aSrc, aCount); + } + + + + + template + static void swapFromBigEndianInPlace(T* aPtr, size_t aCount) + { + maybeSwapInPlace(aPtr, aCount); + } + + + + + + template + __attribute__ ((warn_unused_result)) static T swapFromNetworkOrder(T aValue) + { + return swapFromBigEndian(aValue); + } + + template + static void copyAndSwapFromNetworkOrder(T* aDest, const void* aSrc, + size_t aCount) + { + copyAndSwapFromBigEndian(aDest, aSrc, aCount); + } + + template + static void swapFromNetworkOrderInPlace(T* aPtr, size_t aCount) + { + swapFromBigEndianInPlace(aPtr, aCount); + } + +private: + + + + + template + static T read(const void* aPtr) + { + union + { + T mVal; + uint8_t mBuffer[sizeof(T)]; + } u; + memcpy(u.mBuffer, aPtr, sizeof(T)); + return maybeSwap(u.mVal); + } + + + + + + template + static void write(void* aPtr, T aValue) + { + T tmp = maybeSwap(aValue); + memcpy(aPtr, &tmp, sizeof(T)); + } + + Endian() = delete; + Endian(const Endian& aTther) = delete; + void operator=(const Endian& aOther) = delete; +}; + +template +class EndianReadWrite : public Endian +{ +private: + typedef Endian super; + +public: + using super::readUint16; + using super::readUint32; + using super::readUint64; + using super::readInt16; + using super::readInt32; + using super::readInt64; + using super::writeUint16; + using super::writeUint32; + using super::writeUint64; + using super::writeInt16; + using super::writeInt32; + using super::writeInt64; +}; + +} + +class LittleEndian final : public detail::EndianReadWrite +{}; + +class BigEndian final : public detail::EndianReadWrite +{}; + +typedef BigEndian NetworkEndian; + +class NativeEndian final : public detail::Endian +{ +private: + typedef detail::Endian super; + +public: + + + + + + using super::swapToLittleEndian; + using super::copyAndSwapToLittleEndian; + using super::swapToLittleEndianInPlace; + using super::swapToBigEndian; + using super::copyAndSwapToBigEndian; + using super::swapToBigEndianInPlace; + using super::swapToNetworkOrder; + using super::copyAndSwapToNetworkOrder; + using super::swapToNetworkOrderInPlace; + + + + + + + using super::swapFromLittleEndian; + using super::copyAndSwapFromLittleEndian; + using super::swapFromLittleEndianInPlace; + using super::swapFromBigEndian; + using super::copyAndSwapFromBigEndian; + using super::swapFromBigEndianInPlace; + using super::swapFromNetworkOrder; + using super::copyAndSwapFromNetworkOrder; + using super::swapFromNetworkOrderInPlace; +}; + + + +} +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jscpucfg.h" 2 +# 140 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jstypes.h" 2 +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2 + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Result.h" 1 +# 119 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Result.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Result.h" 1 +# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Result.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Variant.h" 1 +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Variant.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OperatorNewExtensions.h" 1 +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OperatorNewExtensions.h" +namespace mozilla { +enum NotNullTag { + KnownNotNull, +}; +} +# 45 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OperatorNewExtensions.h" +inline void* +operator new(size_t, mozilla::NotNullTag, void* p) +{ + do { } while (0); + return p; +} +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Variant.h" 2 + + + + + + +namespace mozilla { + +template +class Variant; + +namespace detail { + +template +struct FirstTypeIsInRest; + +template +struct FirstTypeIsInRest : FalseType {}; + +template +struct FirstTypeIsInRest +{ + static constexpr bool value = + IsSame::value || + FirstTypeIsInRest::value; +}; + +template +struct TypesAreDistinct; + +template <> +struct TypesAreDistinct<> : TrueType { }; + +template +struct TypesAreDistinct +{ + static constexpr bool value = + !FirstTypeIsInRest::value && + TypesAreDistinct::value; +}; + + + + + + +template +struct IsVariant; + +template +struct IsVariant : FalseType {}; + +template +struct IsVariant : TrueType {}; + +template +struct IsVariant : public IsVariant { }; + + +template +struct SelectVariantTypeHelper; + +template +struct SelectVariantTypeHelper +{ }; + +template +struct SelectVariantTypeHelper +{ + typedef T Type; +}; + +template +struct SelectVariantTypeHelper +{ + typedef const T Type; +}; + +template +struct SelectVariantTypeHelper +{ + typedef const T& Type; +}; + +template +struct SelectVariantTypeHelper +{ + typedef T&& Type; +}; + +template +struct SelectVariantTypeHelper + : public SelectVariantTypeHelper +{ }; + + + + + + +template +struct SelectVariantType + : public SelectVariantTypeHelper::Type>::Type, + Variants...> +{ }; + + + +template +struct VariantTag +{ +private: + static const size_t TypeCount = sizeof...(Ts); + +public: + using Type = + typename Conditional::Type + >::Type; +}; + + + + + +template +struct TagHelper; + + +template +struct TagHelper +{ + static Tag tag() { return Next::template tag(); } +}; + + +template +struct TagHelper +{ + static Tag tag() { return Tag(N); } +}; + + + + + + + +template +struct VariantImplementation; + + +template +struct VariantImplementation +{ + template + static Tag tag() { + static_assert(mozilla::IsSame::value, + "mozilla::Variant: tag: bad type!"); + return Tag(N); + } + + template + static void copyConstruct(void* aLhs, const Variant& aRhs) { + ::new (KnownNotNull, aLhs) T(aRhs.template as()); + } + + template + static void moveConstruct(void* aLhs, Variant&& aRhs) { + ::new (KnownNotNull, aLhs) T(aRhs.template extract()); + } + + template + static void destroy(Variant& aV) { + aV.template as().~T(); + } + + template + static bool + equal(const Variant& aLhs, const Variant& aRhs) { + return aLhs.template as() == aRhs.template as(); + } + + template + static auto + match(Matcher&& aMatcher, ConcreteVariant& aV) + -> decltype(aMatcher.match(aV.template as())) + { + return aMatcher.match(aV.template as()); + } +}; + + +template +struct VariantImplementation +{ + + using Next = VariantImplementation; + + template + static Tag tag() { + return TagHelper::value>::tag(); + } + + template + static void copyConstruct(void* aLhs, const Variant& aRhs) { + if (aRhs.template is()) { + ::new (KnownNotNull, aLhs) T(aRhs.template as()); + } else { + Next::copyConstruct(aLhs, aRhs); + } + } + + template + static void moveConstruct(void* aLhs, Variant&& aRhs) { + if (aRhs.template is()) { + ::new (KnownNotNull, aLhs) T(aRhs.template extract()); + } else { + Next::moveConstruct(aLhs, aRhs); + } + } + + template + static void destroy(Variant& aV) { + if (aV.template is()) { + aV.template as().~T(); + } else { + Next::destroy(aV); + } + } + + template + static bool equal(const Variant& aLhs, const Variant& aRhs) { + if (aLhs.template is()) { + do { } while (0); + return aLhs.template as() == aRhs.template as(); + } else { + return Next::equal(aLhs, aRhs); + } + } + + template + static auto + match(Matcher&& aMatcher, ConcreteVariant& aV) + -> decltype(aMatcher.match(aV.template as())) + { + if (aV.template is()) { + return aMatcher.match(aV.template as()); + } else { +# 278 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Variant.h" + return Next::match(aMatcher, aV); + } + } +}; + + + + + + + +template +struct AsVariantTemporary +{ + explicit AsVariantTemporary(const T& aValue) + : mValue(aValue) + {} + + template + explicit AsVariantTemporary(U&& aValue) + : mValue(Forward(aValue)) + {} + + AsVariantTemporary(const AsVariantTemporary& aOther) + : mValue(aOther.mValue) + {} + + AsVariantTemporary(AsVariantTemporary&& aOther) + : mValue(Move(aOther.mValue)) + {} + + AsVariantTemporary() = delete; + void operator=(const AsVariantTemporary&) = delete; + void operator=(AsVariantTemporary&&) = delete; + + typename RemoveConst::Type>::Type mValue; +}; + +} +# 447 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Variant.h" +template +class Variant +{ + static_assert(detail::TypesAreDistinct::value, + "Variant with duplicate types is not supported"); + + using Tag = typename detail::VariantTag::Type; + using Impl = detail::VariantImplementation; + + static constexpr size_t RawDataAlignment = tl::Max::value; + static constexpr size_t RawDataSize = tl::Max::value; + + + alignas(RawDataAlignment) unsigned char rawData[RawDataSize]; + + + + Tag tag; + + + + + + void* ptr() { + return rawData; + } + + const void* ptr() const { + return rawData; + } + +public: + + template::Type> + explicit Variant(RefT&& aT) + : tag(Impl::template tag()) + { + ::new (KnownNotNull, ptr()) T(Forward(aT)); + } + + + + + + + template::Type> + Variant(detail::AsVariantTemporary&& aValue) + : tag(Impl::template tag()) + { + ::new (KnownNotNull, ptr()) T(Move(aValue.mValue)); + } + + + Variant(const Variant& aRhs) + : tag(aRhs.tag) + { + Impl::copyConstruct(ptr(), aRhs); + } + + + Variant(Variant&& aRhs) + : tag(aRhs.tag) + { + Impl::moveConstruct(ptr(), Move(aRhs)); + } + + + Variant& operator=(const Variant& aRhs) { + do { } while (0); + this->~Variant(); + ::new (KnownNotNull, this) Variant(aRhs); + return *this; + } + + + Variant& operator=(Variant&& aRhs) { + do { } while (0); + this->~Variant(); + ::new (KnownNotNull, this) Variant(Move(aRhs)); + return *this; + } + + + template + Variant& operator=(detail::AsVariantTemporary&& aValue) + { + this->~Variant(); + ::new (KnownNotNull, this) Variant(Move(aValue)); + return *this; + } + + ~Variant() + { + Impl::destroy(*this); + } + + + template + bool is() const { + static_assert(detail::IsVariant::value, + "provided a type not found in this Variant's type list"); + return Impl::template tag() == tag; + } + + + + + + bool operator==(const Variant& aRhs) const { + return tag == aRhs.tag && Impl::equal(*this, aRhs); + } + + + + + + + bool operator!=(const Variant& aRhs) const { + return !(*this == aRhs); + } + + + + + template + T& as() { + static_assert(detail::IsVariant::value, + "provided a type not found in this Variant's type list"); + do { static_assert(mozilla::detail::AssertionConditionType())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(is()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "is()" ")"); do { *((volatile int*) __null) = 581; ::abort(); } while (0); } } while (0); + return *static_cast(ptr()); + } + + + template + const T& as() const { + static_assert(detail::IsVariant::value, + "provided a type not found in this Variant's type list"); + do { static_assert(mozilla::detail::AssertionConditionType())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(is()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "is()" ")"); do { *((volatile int*) __null) = 590; ::abort(); } while (0); } } while (0); + return *static_cast(ptr()); + } + + + + + + + + template + T extract() { + static_assert(detail::IsVariant::value, + "provided a type not found in this Variant's type list"); + do { } while (0); + return T(Move(as())); + } + + + + + template + auto + match(Matcher&& aMatcher) const + -> decltype(Impl::match(aMatcher, *this)) + { + return Impl::match(aMatcher, *this); + } + + + template + auto + match(Matcher&& aMatcher) + -> decltype(Impl::match(aMatcher, *this)) + { + return Impl::match(aMatcher, *this); + } +}; +# 642 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Variant.h" +template +detail::AsVariantTemporary +AsVariant(T&& aValue) +{ + return detail::AsVariantTemporary(Forward(aValue)); +} + +} +# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Result.h" 2 + +namespace mozilla { + + + + + + +struct Ok {}; + +template class GenericErrorResult; +template class Result; + +namespace detail { + +enum class PackingStrategy { + Variant, + NullIsOk, + LowBitTagIsError, + PackedVariant, +}; + +template +class ResultImplementation; + +template +class ResultImplementation +{ + mozilla::Variant mStorage; + +public: + explicit ResultImplementation(V aValue) : mStorage(aValue) {} + explicit ResultImplementation(E aErrorValue) : mStorage(aErrorValue) {} + + bool isOk() const { return mStorage.template is(); } + + + + + V unwrap() const { return mStorage.template as(); } + E unwrapErr() const { return mStorage.template as(); } +}; + + + + + +template +class ResultImplementation +{ + mozilla::Variant mStorage; + +public: + explicit ResultImplementation(V aValue) : mStorage(aValue) {} + explicit ResultImplementation(E& aErrorValue) : mStorage(&aErrorValue) {} + + bool isOk() const { return mStorage.template is(); } + V unwrap() const { return mStorage.template as(); } + E& unwrapErr() const { return *mStorage.template as(); } +}; + + + + + +template +class ResultImplementation +{ + E* mErrorValue; + +public: + explicit ResultImplementation(V) : mErrorValue(nullptr) {} + explicit ResultImplementation(E& aErrorValue) : mErrorValue(&aErrorValue) {} + + bool isOk() const { return mErrorValue == nullptr; } + + V unwrap() const { return V(); } + E& unwrapErr() const { return *mErrorValue; } +}; + + + + + +template +class ResultImplementation +{ + uintptr_t mBits; + +public: + explicit ResultImplementation(V* aValue) + : mBits(reinterpret_cast(aValue)) + { + do { } while (0); + + } + explicit ResultImplementation(E& aErrorValue) + : mBits(reinterpret_cast(&aErrorValue) | 1) + { + do { } while (0); + + } + + bool isOk() const { return (mBits & 1) == 0; } + + V* unwrap() const { return reinterpret_cast(mBits); } + E& unwrapErr() const { return *reinterpret_cast(mBits ^ 1); } +}; + + +template +struct IsPackableVariant +{ + struct VEbool { + V v; + E e; + bool ok; + }; + struct EVbool { + E e; + V v; + bool ok; + }; + + using Impl = typename Conditional::Type; + + static const bool value = sizeof(Impl) <= sizeof(uintptr_t); +}; + + + + + +template +class ResultImplementation +{ + using Impl = typename IsPackableVariant::Impl; + Impl data; + +public: + explicit ResultImplementation(V aValue) + { + data.v = aValue; + data.ok = true; + } + explicit ResultImplementation(E aErrorValue) + { + data.e = aErrorValue; + data.ok = false; + } + + bool isOk() const { return data.ok; } + + V unwrap() const { return data.v; } + E unwrapErr() const { return data.e; } +}; + + + + + +template +struct UnusedZero +{ + static const bool value = false; +}; + + +template +struct UnusedZero +{ + static const bool value = true; +}; + + + + +template struct HasFreeLSB { static const bool value = false; }; + + + + +template struct HasFreeLSB { + static const bool value = (mozilla::AlignmentFinder::alignment & 1) == 0; +}; + + + +template struct HasFreeLSB { + static const bool value = HasFreeLSB::value; +}; + + + +template +struct SelectResultImpl +{ + static const PackingStrategy value = + (IsEmpty::value && UnusedZero::value) + ? PackingStrategy::NullIsOk + : (detail::HasFreeLSB::value && detail::HasFreeLSB::value) + ? PackingStrategy::LowBitTagIsError + : (IsDefaultConstructible::value && IsDefaultConstructible::value && + IsPackableVariant::value) + ? PackingStrategy::PackedVariant + : PackingStrategy::Variant; + + using Type = detail::ResultImplementation; +}; + +template +struct IsResult : FalseType { }; + +template +struct IsResult> : TrueType { }; + +} +# 263 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Result.h" +template +class Result final +{ + using Impl = typename detail::SelectResultImpl::Type; + + Impl mImpl; + +public: + + + + Result(V aValue) : mImpl(aValue) { do { } while (0); } + + + + + explicit Result(E aErrorValue) : mImpl(aErrorValue) { do { } while (0); } + + + + + + template + Result(const GenericErrorResult& aErrorResult) + : mImpl(aErrorResult.mErrorValue) + { + static_assert(mozilla::IsConvertible::value, + "E2 must be convertible to E"); + do { } while (0); + } + + Result(const Result&) = default; + Result& operator=(const Result&) = default; + + + bool isOk() const { return mImpl.isOk(); } + + + bool isErr() const { return !mImpl.isOk(); } + + + V unwrap() const { + do { } while (0); + return mImpl.unwrap(); + } + + + E unwrapErr() const { + do { } while (0); + return mImpl.unwrapErr(); + } +# 340 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Result.h" + template + auto map(F f) const -> Result { + using RetResult = Result; + return isOk() ? RetResult(f(unwrap())) : RetResult(unwrapErr()); + } +# 374 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Result.h" + template< + typename F, + typename = typename EnableIf< + detail::IsResult::value + >::Type + > + auto andThen(F f) const -> decltype(f(*((V*) nullptr))) { + return isOk() ? f(unwrap()) : GenericErrorResult(unwrapErr()); + } +}; + + + + + + + +template +class GenericErrorResult +{ + E mErrorValue; + + template friend class Result; + +public: + explicit GenericErrorResult(E aErrorValue) : mErrorValue(aErrorValue) {} +}; + +template +inline GenericErrorResult +Err(E&& aErrorValue) +{ + return GenericErrorResult(aErrorValue); +} + +} +# 120 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Result.h" 2 + +struct JSContext; +# 179 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Result.h" +namespace JS { + +using mozilla::Ok; + + + + + +struct Error +{ + + + int dummy; +}; + +struct OOM : public Error +{ +}; +# 213 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Result.h" +template +using Result = mozilla::Result; + +static_assert(sizeof(Result<>) == sizeof(uintptr_t), + "Result<> should be pointer-sized"); + +static_assert(sizeof(Result) == sizeof(uintptr_t), + "Result should be pointer-sized"); + +} +# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TraceKind.h" 1 +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TraceKind.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TypeDecls.h" 1 +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TypeDecls.h" +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TypeDecls.h" 2 + + + + +struct JSContext; +class JSFunction; +class JSObject; +class JSScript; +class JSString; +class JSAddonId; + +struct jsid; + +namespace JS { + +typedef unsigned char Latin1Char; + +class Symbol; +class Value; +template class Handle; +template class MutableHandle; +template class Rooted; +template class PersistentRooted; + +typedef Handle HandleFunction; +typedef Handle HandleId; +typedef Handle HandleObject; +typedef Handle HandleScript; +typedef Handle HandleString; +typedef Handle HandleSymbol; +typedef Handle HandleValue; + +typedef MutableHandle MutableHandleFunction; +typedef MutableHandle MutableHandleId; +typedef MutableHandle MutableHandleObject; +typedef MutableHandle MutableHandleScript; +typedef MutableHandle MutableHandleString; +typedef MutableHandle MutableHandleSymbol; +typedef MutableHandle MutableHandleValue; + +typedef Rooted RootedObject; +typedef Rooted RootedFunction; +typedef Rooted RootedScript; +typedef Rooted RootedString; +typedef Rooted RootedSymbol; +typedef Rooted RootedId; +typedef Rooted RootedValue; + +typedef PersistentRooted PersistentRootedFunction; +typedef PersistentRooted PersistentRootedId; +typedef PersistentRooted PersistentRootedObject; +typedef PersistentRooted PersistentRootedScript; +typedef PersistentRooted PersistentRootedString; +typedef PersistentRooted PersistentRootedSymbol; +typedef PersistentRooted PersistentRootedValue; + +} +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TraceKind.h" 2 + + +namespace js { +class BaseShape; +class LazyScript; +class ObjectGroup; +class RegExpShared; +class Shape; +class Scope; +namespace jit { +class JitCode; +} +} + +namespace JS { +# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TraceKind.h" +enum class TraceKind +{ + + + + Object = 0x00, + String = 0x02, + Symbol = 0x03, + + + Script = 0x01, + + + Shape = 0x04, + + + ObjectGroup = 0x05, + + + Null = 0x06, + + + BaseShape = 0x0F, + JitCode = 0x1F, + LazyScript = 0x2F, + Scope = 0x3F, + RegExpShared = 0x4F +}; +const static uintptr_t OutOfLineTraceKindMask = 0x07; +static_assert(uintptr_t(JS::TraceKind::BaseShape) & OutOfLineTraceKindMask, "mask bits are set"); +static_assert(uintptr_t(JS::TraceKind::JitCode) & OutOfLineTraceKindMask, "mask bits are set"); +static_assert(uintptr_t(JS::TraceKind::LazyScript) & OutOfLineTraceKindMask, "mask bits are set"); +static_assert(uintptr_t(JS::TraceKind::Scope) & OutOfLineTraceKindMask, "mask bits are set"); +static_assert(uintptr_t(JS::TraceKind::RegExpShared) & OutOfLineTraceKindMask, "mask bits are set"); + + + + +template +struct MapTypeToTraceKind { + static const JS::TraceKind kind = T::TraceKind; +}; +# 102 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TraceKind.h" +template <> struct MapTypeToTraceKind { static const JS::TraceKind kind = JS::TraceKind::BaseShape; }; template <> struct MapTypeToTraceKind { static const JS::TraceKind kind = JS::TraceKind::JitCode; }; template <> struct MapTypeToTraceKind { static const JS::TraceKind kind = JS::TraceKind::LazyScript; }; template <> struct MapTypeToTraceKind { static const JS::TraceKind kind = JS::TraceKind::Scope; }; template <> struct MapTypeToTraceKind { static const JS::TraceKind kind = JS::TraceKind::Object; }; template <> struct MapTypeToTraceKind { static const JS::TraceKind kind = JS::TraceKind::ObjectGroup; }; template <> struct MapTypeToTraceKind { static const JS::TraceKind kind = JS::TraceKind::Script; }; template <> struct MapTypeToTraceKind { static const JS::TraceKind kind = JS::TraceKind::Shape; }; template <> struct MapTypeToTraceKind { static const JS::TraceKind kind = JS::TraceKind::String; }; template <> struct MapTypeToTraceKind { static const JS::TraceKind kind = JS::TraceKind::Symbol; }; template <> struct MapTypeToTraceKind { static const JS::TraceKind kind = JS::TraceKind::RegExpShared; };; + + + + + +enum class RootKind : int8_t +{ + + + +BaseShape, JitCode, LazyScript, Scope, Object, ObjectGroup, Script, Shape, String, Symbol, RegExpShared, + + + + Id, + Value, + + + Traceable, + + Limit +}; + + +template struct MapTraceKindToRootKind {}; + + + + +template <> struct MapTraceKindToRootKind { static const JS::RootKind kind = JS::RootKind::BaseShape; }; template <> struct MapTraceKindToRootKind { static const JS::RootKind kind = JS::RootKind::JitCode; }; template <> struct MapTraceKindToRootKind { static const JS::RootKind kind = JS::RootKind::LazyScript; }; template <> struct MapTraceKindToRootKind { static const JS::RootKind kind = JS::RootKind::Scope; }; template <> struct MapTraceKindToRootKind { static const JS::RootKind kind = JS::RootKind::Object; }; template <> struct MapTraceKindToRootKind { static const JS::RootKind kind = JS::RootKind::ObjectGroup; }; template <> struct MapTraceKindToRootKind { static const JS::RootKind kind = JS::RootKind::Script; }; template <> struct MapTraceKindToRootKind { static const JS::RootKind kind = JS::RootKind::Shape; }; template <> struct MapTraceKindToRootKind { static const JS::RootKind kind = JS::RootKind::String; }; template <> struct MapTraceKindToRootKind { static const JS::RootKind kind = JS::RootKind::Symbol; }; template <> struct MapTraceKindToRootKind { static const JS::RootKind kind = JS::RootKind::RegExpShared; }; + + + + + +template +struct MapTypeToRootKind { + static const JS::RootKind kind = JS::RootKind::Traceable; +}; +template +struct MapTypeToRootKind { + static const JS::RootKind kind = + JS::MapTraceKindToRootKind::kind>::kind; +}; +template +struct MapTypeToRootKind> { + static const JS::RootKind kind = JS::MapTypeToRootKind::kind; +}; +template <> struct MapTypeToRootKind { + static const JS::RootKind kind = JS::RootKind::Value; +}; +template <> struct MapTypeToRootKind { + static const JS::RootKind kind = JS::RootKind::Id; +}; +template <> struct MapTypeToRootKind : public MapTypeToRootKind {}; +# 183 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TraceKind.h" +template +auto +DispatchTraceKindTyped(F f, JS::TraceKind traceKind, Args&&... args) + -> decltype(f. template operator()(mozilla::Forward(args)...)) +{ + switch (traceKind) { + + + + case JS::TraceKind::BaseShape: return f. template operator()(mozilla::Forward(args)...); case JS::TraceKind::JitCode: return f. template operator()(mozilla::Forward(args)...); case JS::TraceKind::LazyScript: return f. template operator()(mozilla::Forward(args)...); case JS::TraceKind::Scope: return f. template operator()(mozilla::Forward(args)...); case JS::TraceKind::Object: return f. template operator()(mozilla::Forward(args)...); case JS::TraceKind::ObjectGroup: return f. template operator()(mozilla::Forward(args)...); case JS::TraceKind::Script: return f. template operator()(mozilla::Forward(args)...); case JS::TraceKind::Shape: return f. template operator()(mozilla::Forward(args)...); case JS::TraceKind::String: return f. template operator()(mozilla::Forward(args)...); case JS::TraceKind::Symbol: return f. template operator()(mozilla::Forward(args)...); case JS::TraceKind::RegExpShared: return f. template operator()(mozilla::Forward(args)...);; + + default: + do { AnnotateMozCrashReason("MOZ_CRASH(" "Invalid trace kind in DispatchTraceKindTyped." ")"); do { *((volatile int*) __null) = 195; ::abort(); } while (0); } while (0); + } +} + + +template +auto +DispatchTraceKindTyped(F f, void* thing, JS::TraceKind traceKind, Args&&... args) + -> decltype(f(static_cast(nullptr), mozilla::Forward(args)...)) +{ + switch (traceKind) { + + + + case JS::TraceKind::BaseShape: return f(static_cast(thing), mozilla::Forward(args)...); case JS::TraceKind::JitCode: return f(static_cast(thing), mozilla::Forward(args)...); case JS::TraceKind::LazyScript: return f(static_cast(thing), mozilla::Forward(args)...); case JS::TraceKind::Scope: return f(static_cast(thing), mozilla::Forward(args)...); case JS::TraceKind::Object: return f(static_cast(thing), mozilla::Forward(args)...); case JS::TraceKind::ObjectGroup: return f(static_cast(thing), mozilla::Forward(args)...); case JS::TraceKind::Script: return f(static_cast(thing), mozilla::Forward(args)...); case JS::TraceKind::Shape: return f(static_cast(thing), mozilla::Forward(args)...); case JS::TraceKind::String: return f(static_cast(thing), mozilla::Forward(args)...); case JS::TraceKind::Symbol: return f(static_cast(thing), mozilla::Forward(args)...); case JS::TraceKind::RegExpShared: return f(static_cast(thing), mozilla::Forward(args)...);; + + default: + do { AnnotateMozCrashReason("MOZ_CRASH(" "Invalid trace kind in DispatchTraceKindTyped." ")"); do { *((volatile int*) __null) = 212; ::abort(); } while (0); } while (0); + } +} + +} +# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2 + + + + + + +namespace JS { + +class AutoIdVector; +class CallArgs; + +template +class Rooted; + +class CompileOptions; +class ReadOnlyCompileOptions; +class OwningCompileOptions; +class TransitiveCompileOptions; +class CompartmentOptions; + +class Value; +struct Zone; + +} + + + + + + +enum JSVersion { + JSVERSION_ECMA_3 = 148, + JSVERSION_1_6 = 160, + JSVERSION_1_7 = 170, + JSVERSION_1_8 = 180, + JSVERSION_ECMA_5 = 185, + JSVERSION_DEFAULT = 0, + JSVERSION_UNKNOWN = -1, + JSVERSION_LATEST = JSVERSION_ECMA_5 +}; + + +enum JSType { + JSTYPE_UNDEFINED, + JSTYPE_OBJECT, + JSTYPE_FUNCTION, + JSTYPE_STRING, + JSTYPE_NUMBER, + JSTYPE_BOOLEAN, + JSTYPE_NULL, + JSTYPE_SYMBOL, + JSTYPE_LIMIT +}; + + +enum JSProtoKey { + + JSProto_Null = 0, JSProto_Object = 1, JSProto_Function = 2, JSProto_Array = 3, JSProto_Boolean = 4, JSProto_JSON = 5, JSProto_Date = 6, JSProto_Math = 7, JSProto_Number = 8, JSProto_String = 9, JSProto_RegExp = 10, JSProto_Error = 11, JSProto_InternalError = 12, JSProto_EvalError = 13, JSProto_RangeError = 14, JSProto_ReferenceError = 15, JSProto_SyntaxError = 16, JSProto_TypeError = 17, JSProto_URIError = 18, JSProto_DebuggeeWouldRun = 19, JSProto_CompileError = 20, JSProto_LinkError = 21, JSProto_RuntimeError = 22, JSProto_Iterator = 23, JSProto_StopIteration = 24, JSProto_ArrayBuffer = 25, JSProto_Int8Array = 26, JSProto_Uint8Array = 27, JSProto_Int16Array = 28, JSProto_Uint16Array = 29, JSProto_Int32Array = 30, JSProto_Uint32Array = 31, JSProto_Float32Array = 32, JSProto_Float64Array = 33, JSProto_Uint8ClampedArray = 34, JSProto_Proxy = 35, JSProto_WeakMap = 36, JSProto_Map = 37, JSProto_Set = 38, JSProto_DataView = 39, JSProto_Symbol = 40, JSProto_SharedArrayBuffer = 41, JSProto_Intl = 42, JSProto_TypedObject = 43, JSProto_Reflect = 44, JSProto_SIMD = 45, JSProto_WeakSet = 46, JSProto_TypedArray = 47, JSProto_Atomics = 48, JSProto_SavedFrame = 49, JSProto_WebAssembly = 50, JSProto_WasmModule = 51, JSProto_WasmInstance = 52, JSProto_WasmMemory = 53, JSProto_WasmTable = 54, JSProto_Promise = 55, + + JSProto_LIMIT +}; + + +struct JSClass; +struct JSCompartment; +struct JSCrossCompartmentCall; +class JSErrorReport; +struct JSExceptionState; +struct JSFunctionSpec; +struct JSLocaleCallbacks; +struct JSObjectMap; +struct JSPrincipals; +struct JSPropertyName; +struct JSPropertySpec; +struct JSRuntime; +struct JSSecurityCallbacks; +struct JSStructuredCloneCallbacks; +struct JSStructuredCloneReader; +struct JSStructuredCloneWriter; +class JSTracer; + +class JSFlatString; + +typedef bool (*JSInitCallback)(void); + +template struct JSConstScalarSpec; +typedef JSConstScalarSpec JSConstDoubleSpec; +typedef JSConstScalarSpec JSConstIntegerSpec; + + + + + +typedef void +(* JSTraceDataOp)(JSTracer* trc, void* data); + +namespace js { +namespace gc { +class AutoTraceSession; +class StoreBuffer; +} + +class CooperatingContext; + +inline JSCompartment* GetContextCompartment(const JSContext* cx); +inline JS::Zone* GetContextZone(const JSContext* cx); + + + +bool +CurrentThreadCanAccessRuntime(const JSRuntime* rt); + + + + + + +} + +namespace JS { + +class AutoEnterCycleCollection; +class AutoAssertOnBarrier; +struct PropertyDescriptor; + +typedef void (*OffThreadCompileCallback)(void* token, void* callbackData); + +enum class HeapState { + Idle, + Tracing, + MajorCollecting, + MinorCollecting, + CycleCollecting +}; + +HeapState +CurrentThreadHeapState(); + +static inline bool +CurrentThreadIsHeapBusy() +{ + return CurrentThreadHeapState() != HeapState::Idle; +} + +static inline bool +CurrentThreadIsHeapTracing() +{ + return CurrentThreadHeapState() == HeapState::Tracing; +} + +static inline bool +CurrentThreadIsHeapMajorCollecting() +{ + return CurrentThreadHeapState() == HeapState::MajorCollecting; +} + +static inline bool +CurrentThreadIsHeapMinorCollecting() +{ + return CurrentThreadHeapState() == HeapState::MinorCollecting; +} + +static inline bool +CurrentThreadIsHeapCollecting() +{ + HeapState state = CurrentThreadHeapState(); + return state == HeapState::MajorCollecting || state == HeapState::MinorCollecting; +} + +static inline bool +CurrentThreadIsHeapCycleCollecting() +{ + return CurrentThreadHeapState() == HeapState::CycleCollecting; +} + + + +class AutoEnterCycleCollection +{ + + + + + + + + public: + explicit AutoEnterCycleCollection(JSContext* cx) {} + ~AutoEnterCycleCollection() {} + +}; + +class RootingContext; + +class AutoGCRooter +{ + public: + AutoGCRooter(JSContext* cx, ptrdiff_t tag); + AutoGCRooter(RootingContext* cx, ptrdiff_t tag); + + ~AutoGCRooter() { + do { } while (0); + *stackTop = down; + } + + + inline void trace(JSTracer* trc); + static void traceAll(const js::CooperatingContext& target, JSTracer* trc); + static void traceAllWrappers(const js::CooperatingContext& target, JSTracer* trc); + + protected: + AutoGCRooter * const down; +# 244 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" + ptrdiff_t tag_; + + enum { + VALARRAY = -2, + PARSER = -3, + VALVECTOR = -10, + IDVECTOR = -11, + OBJVECTOR = -14, + IONMASM = -19, + WRAPVECTOR = -20, + WRAPPER = -21, + CUSTOM = -26 + }; + + static ptrdiff_t GetTag(const Value& value) { return VALVECTOR; } + static ptrdiff_t GetTag(const jsid& id) { return IDVECTOR; } + static ptrdiff_t GetTag(JSObject* obj) { return OBJVECTOR; } + + private: + AutoGCRooter ** const stackTop; + + + AutoGCRooter(AutoGCRooter& ida) = delete; + void operator=(AutoGCRooter& ida) = delete; +}; + + + +template <> +struct MapTypeToRootKind { + static const RootKind kind = RootKind::Traceable; +}; + +using RootedListHeads = mozilla::EnumeratedArray*>; + + + + + + +enum StackKind +{ + StackForSystemCode, + StackForTrustedScript, + StackForUntrustedScript, + StackKindCount +}; + + + +class RootingContext +{ + + RootedListHeads stackRoots_; + template friend class JS::Rooted; + + + JS::AutoGCRooter* autoGCRooters_; + friend class JS::AutoGCRooter; + + public: + RootingContext(); + + void traceStackRoots(JSTracer* trc); + void checkNoGCRooters(); + + protected: + + + + + + JSCompartment* compartment_; + + + JS::Zone* zone_; + + public: + + uintptr_t nativeStackLimit[StackKindCount]; + + static const RootingContext* get(const JSContext* cx) { + return reinterpret_cast(cx); + } + + static RootingContext* get(JSContext* cx) { + return reinterpret_cast(cx); + } + + friend JSCompartment* js::GetContextCompartment(const JSContext* cx); + friend JS::Zone* js::GetContextZone(const JSContext* cx); +}; + +} + +namespace js { +# 352 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" +inline JSCompartment* +GetContextCompartment(const JSContext* cx) +{ + return JS::RootingContext::get(cx)->compartment_; +} + +inline JS::Zone* +GetContextZone(const JSContext* cx) +{ + return JS::RootingContext::get(cx)->zone_; +} + +} + +extern "C" { + + +typedef struct PRFileDesc PRFileDesc; + +} +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionTraversalCallback.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HeapAPI.h" 1 +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HeapAPI.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" 1 +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h" 1 +# 49 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h" +namespace mozilla { +# 81 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h" +enum MemoryOrdering { +# 111 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h" + Relaxed, +# 133 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h" + ReleaseAcquire, +# 162 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h" + SequentiallyConsistent, +}; + +} + + + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/atomic" 1 3 +# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/atomic" 3 + + + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_base.h" 1 3 +# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_base.h" 3 +# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_base.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 55 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_base.h" 3 + typedef enum memory_order + { + memory_order_relaxed, + memory_order_consume, + memory_order_acquire, + memory_order_release, + memory_order_acq_rel, + memory_order_seq_cst + } memory_order; + + enum __memory_order_modifier + { + __memory_order_mask = 0x0ffff, + __memory_order_modifier_mask = 0xffff0000, + __memory_order_hle_acquire = 0x10000, + __memory_order_hle_release = 0x20000 + }; + + constexpr memory_order + operator|(memory_order __m, __memory_order_modifier __mod) + { + return memory_order(__m | int(__mod)); + } + + constexpr memory_order + operator&(memory_order __m, __memory_order_modifier __mod) + { + return memory_order(__m & int(__mod)); + } + + + constexpr memory_order + __cmpexch_failure_order2(memory_order __m) noexcept + { + return __m == memory_order_acq_rel ? memory_order_acquire + : __m == memory_order_release ? memory_order_relaxed : __m; + } + + constexpr memory_order + __cmpexch_failure_order(memory_order __m) noexcept + { + return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask) + | (__m & __memory_order_modifier_mask)); + } + + inline __attribute__((__always_inline__)) void + atomic_thread_fence(memory_order __m) noexcept + { __atomic_thread_fence(__m); } + + inline __attribute__((__always_inline__)) void + atomic_signal_fence(memory_order __m) noexcept + { __atomic_signal_fence(__m); } + + + template + inline _Tp + kill_dependency(_Tp __y) noexcept + { + _Tp __ret(__y); + return __ret; + } + + + + template + struct __atomic_base; + + + + + template + struct atomic; + + template + struct atomic<_Tp*>; + + + + typedef bool __atomic_flag_data_type; +# 148 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_base.h" 3 + extern "C" { + + struct __atomic_flag_base + { + __atomic_flag_data_type _M_i; + }; + + } + + + + + struct atomic_flag : public __atomic_flag_base + { + atomic_flag() noexcept = default; + ~atomic_flag() noexcept = default; + atomic_flag(const atomic_flag&) = delete; + atomic_flag& operator=(const atomic_flag&) = delete; + atomic_flag& operator=(const atomic_flag&) volatile = delete; + + + constexpr atomic_flag(bool __i) noexcept + : __atomic_flag_base{ _S_init(__i) } + { } + + inline __attribute__((__always_inline__)) bool + test_and_set(memory_order __m = memory_order_seq_cst) noexcept + { + return __atomic_test_and_set (&_M_i, __m); + } + + inline __attribute__((__always_inline__)) bool + test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept + { + return __atomic_test_and_set (&_M_i, __m); + } + + inline __attribute__((__always_inline__)) void + clear(memory_order __m = memory_order_seq_cst) noexcept + { + memory_order __b = __m & __memory_order_mask; + ; + ; + ; + + __atomic_clear (&_M_i, __m); + } + + inline __attribute__((__always_inline__)) void + clear(memory_order __m = memory_order_seq_cst) volatile noexcept + { + memory_order __b = __m & __memory_order_mask; + ; + ; + ; + + __atomic_clear (&_M_i, __m); + } + + private: + static constexpr __atomic_flag_data_type + _S_init(bool __i) + { return __i ? 1 : 0; } + }; +# 237 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_base.h" 3 + template + struct __atomic_base + { + private: + typedef _ITp __int_type; + + static constexpr int _S_alignment = + sizeof(_ITp) > alignof(_ITp) ? sizeof(_ITp) : alignof(_ITp); + + alignas(_S_alignment) __int_type _M_i; + + public: + __atomic_base() noexcept = default; + ~__atomic_base() noexcept = default; + __atomic_base(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) volatile = delete; + + + constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { } + + operator __int_type() const noexcept + { return load(); } + + operator __int_type() const volatile noexcept + { return load(); } + + __int_type + operator=(__int_type __i) noexcept + { + store(__i); + return __i; + } + + __int_type + operator=(__int_type __i) volatile noexcept + { + store(__i); + return __i; + } + + __int_type + operator++(int) noexcept + { return fetch_add(1); } + + __int_type + operator++(int) volatile noexcept + { return fetch_add(1); } + + __int_type + operator--(int) noexcept + { return fetch_sub(1); } + + __int_type + operator--(int) volatile noexcept + { return fetch_sub(1); } + + __int_type + operator++() noexcept + { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); } + + __int_type + operator++() volatile noexcept + { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); } + + __int_type + operator--() noexcept + { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); } + + __int_type + operator--() volatile noexcept + { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); } + + __int_type + operator+=(__int_type __i) noexcept + { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator+=(__int_type __i) volatile noexcept + { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator-=(__int_type __i) noexcept + { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator-=(__int_type __i) volatile noexcept + { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator&=(__int_type __i) noexcept + { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator&=(__int_type __i) volatile noexcept + { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator|=(__int_type __i) noexcept + { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator|=(__int_type __i) volatile noexcept + { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator^=(__int_type __i) noexcept + { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator^=(__int_type __i) volatile noexcept + { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); } + + bool + is_lock_free() const noexcept + { + + return __atomic_is_lock_free(sizeof(_M_i), + reinterpret_cast(-__alignof(_M_i))); + } + + bool + is_lock_free() const volatile noexcept + { + + return __atomic_is_lock_free(sizeof(_M_i), + reinterpret_cast(-__alignof(_M_i))); + } + + inline __attribute__((__always_inline__)) void + store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept + { + memory_order __b = __m & __memory_order_mask; + ; + ; + ; + + __atomic_store_n(&_M_i, __i, __m); + } + + inline __attribute__((__always_inline__)) void + store(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + memory_order __b = __m & __memory_order_mask; + ; + ; + ; + + __atomic_store_n(&_M_i, __i, __m); + } + + inline __attribute__((__always_inline__)) __int_type + load(memory_order __m = memory_order_seq_cst) const noexcept + { + memory_order __b = __m & __memory_order_mask; + ; + ; + + return __atomic_load_n(&_M_i, __m); + } + + inline __attribute__((__always_inline__)) __int_type + load(memory_order __m = memory_order_seq_cst) const volatile noexcept + { + memory_order __b = __m & __memory_order_mask; + ; + ; + + return __atomic_load_n(&_M_i, __m); + } + + inline __attribute__((__always_inline__)) __int_type + exchange(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { + return __atomic_exchange_n(&_M_i, __i, __m); + } + + + inline __attribute__((__always_inline__)) __int_type + exchange(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return __atomic_exchange_n(&_M_i, __i, __m); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m1, memory_order __m2) noexcept + { + memory_order __b2 = __m2 & __memory_order_mask; + memory_order __b1 = __m1 & __memory_order_mask; + ; + ; + ; + + return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m1, + memory_order __m2) volatile noexcept + { + memory_order __b2 = __m2 & __memory_order_mask; + memory_order __b1 = __m1 & __memory_order_mask; + ; + ; + ; + + return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) noexcept + { + return compare_exchange_weak(__i1, __i2, __m, + __cmpexch_failure_order(__m)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return compare_exchange_weak(__i1, __i2, __m, + __cmpexch_failure_order(__m)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m1, memory_order __m2) noexcept + { + memory_order __b2 = __m2 & __memory_order_mask; + memory_order __b1 = __m1 & __memory_order_mask; + ; + ; + ; + + return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m1, + memory_order __m2) volatile noexcept + { + memory_order __b2 = __m2 & __memory_order_mask; + memory_order __b1 = __m1 & __memory_order_mask; + + ; + ; + ; + + return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) noexcept + { + return compare_exchange_strong(__i1, __i2, __m, + __cmpexch_failure_order(__m)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return compare_exchange_strong(__i1, __i2, __m, + __cmpexch_failure_order(__m)); + } + + inline __attribute__((__always_inline__)) __int_type + fetch_add(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_add(&_M_i, __i, __m); } + + inline __attribute__((__always_inline__)) __int_type + fetch_add(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_add(&_M_i, __i, __m); } + + inline __attribute__((__always_inline__)) __int_type + fetch_sub(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_sub(&_M_i, __i, __m); } + + inline __attribute__((__always_inline__)) __int_type + fetch_sub(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_sub(&_M_i, __i, __m); } + + inline __attribute__((__always_inline__)) __int_type + fetch_and(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_and(&_M_i, __i, __m); } + + inline __attribute__((__always_inline__)) __int_type + fetch_and(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_and(&_M_i, __i, __m); } + + inline __attribute__((__always_inline__)) __int_type + fetch_or(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_or(&_M_i, __i, __m); } + + inline __attribute__((__always_inline__)) __int_type + fetch_or(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_or(&_M_i, __i, __m); } + + inline __attribute__((__always_inline__)) __int_type + fetch_xor(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_xor(&_M_i, __i, __m); } + + inline __attribute__((__always_inline__)) __int_type + fetch_xor(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_xor(&_M_i, __i, __m); } + }; + + + + template + struct __atomic_base<_PTp*> + { + private: + typedef _PTp* __pointer_type; + + __pointer_type _M_p; + + + constexpr ptrdiff_t + _M_type_size(ptrdiff_t __d) const { return __d * sizeof(_PTp); } + + constexpr ptrdiff_t + _M_type_size(ptrdiff_t __d) const volatile { return __d * sizeof(_PTp); } + + public: + __atomic_base() noexcept = default; + ~__atomic_base() noexcept = default; + __atomic_base(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) volatile = delete; + + + constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { } + + operator __pointer_type() const noexcept + { return load(); } + + operator __pointer_type() const volatile noexcept + { return load(); } + + __pointer_type + operator=(__pointer_type __p) noexcept + { + store(__p); + return __p; + } + + __pointer_type + operator=(__pointer_type __p) volatile noexcept + { + store(__p); + return __p; + } + + __pointer_type + operator++(int) noexcept + { return fetch_add(1); } + + __pointer_type + operator++(int) volatile noexcept + { return fetch_add(1); } + + __pointer_type + operator--(int) noexcept + { return fetch_sub(1); } + + __pointer_type + operator--(int) volatile noexcept + { return fetch_sub(1); } + + __pointer_type + operator++() noexcept + { return __atomic_add_fetch(&_M_p, _M_type_size(1), + memory_order_seq_cst); } + + __pointer_type + operator++() volatile noexcept + { return __atomic_add_fetch(&_M_p, _M_type_size(1), + memory_order_seq_cst); } + + __pointer_type + operator--() noexcept + { return __atomic_sub_fetch(&_M_p, _M_type_size(1), + memory_order_seq_cst); } + + __pointer_type + operator--() volatile noexcept + { return __atomic_sub_fetch(&_M_p, _M_type_size(1), + memory_order_seq_cst); } + + __pointer_type + operator+=(ptrdiff_t __d) noexcept + { return __atomic_add_fetch(&_M_p, _M_type_size(__d), + memory_order_seq_cst); } + + __pointer_type + operator+=(ptrdiff_t __d) volatile noexcept + { return __atomic_add_fetch(&_M_p, _M_type_size(__d), + memory_order_seq_cst); } + + __pointer_type + operator-=(ptrdiff_t __d) noexcept + { return __atomic_sub_fetch(&_M_p, _M_type_size(__d), + memory_order_seq_cst); } + + __pointer_type + operator-=(ptrdiff_t __d) volatile noexcept + { return __atomic_sub_fetch(&_M_p, _M_type_size(__d), + memory_order_seq_cst); } + + bool + is_lock_free() const noexcept + { + + return __atomic_is_lock_free(sizeof(_M_p), + reinterpret_cast(-__alignof(_M_p))); + } + + bool + is_lock_free() const volatile noexcept + { + + return __atomic_is_lock_free(sizeof(_M_p), + reinterpret_cast(-__alignof(_M_p))); + } + + inline __attribute__((__always_inline__)) void + store(__pointer_type __p, + memory_order __m = memory_order_seq_cst) noexcept + { + memory_order __b = __m & __memory_order_mask; + + ; + ; + ; + + __atomic_store_n(&_M_p, __p, __m); + } + + inline __attribute__((__always_inline__)) void + store(__pointer_type __p, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + memory_order __b = __m & __memory_order_mask; + ; + ; + ; + + __atomic_store_n(&_M_p, __p, __m); + } + + inline __attribute__((__always_inline__)) __pointer_type + load(memory_order __m = memory_order_seq_cst) const noexcept + { + memory_order __b = __m & __memory_order_mask; + ; + ; + + return __atomic_load_n(&_M_p, __m); + } + + inline __attribute__((__always_inline__)) __pointer_type + load(memory_order __m = memory_order_seq_cst) const volatile noexcept + { + memory_order __b = __m & __memory_order_mask; + ; + ; + + return __atomic_load_n(&_M_p, __m); + } + + inline __attribute__((__always_inline__)) __pointer_type + exchange(__pointer_type __p, + memory_order __m = memory_order_seq_cst) noexcept + { + return __atomic_exchange_n(&_M_p, __p, __m); + } + + + inline __attribute__((__always_inline__)) __pointer_type + exchange(__pointer_type __p, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return __atomic_exchange_n(&_M_p, __p, __m); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, + memory_order __m2) noexcept + { + memory_order __b2 = __m2 & __memory_order_mask; + memory_order __b1 = __m1 & __memory_order_mask; + ; + ; + ; + + return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, + memory_order __m2) volatile noexcept + { + memory_order __b2 = __m2 & __memory_order_mask; + memory_order __b1 = __m1 & __memory_order_mask; + + ; + ; + ; + + return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2); + } + + inline __attribute__((__always_inline__)) __pointer_type + fetch_add(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); } + + inline __attribute__((__always_inline__)) __pointer_type + fetch_add(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); } + + inline __attribute__((__always_inline__)) __pointer_type + fetch_sub(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); } + + inline __attribute__((__always_inline__)) __pointer_type + fetch_sub(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); } + }; + + + + +} +# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/atomic" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + struct atomic; + + + + template<> + struct atomic + { + private: + __atomic_base _M_base; + + public: + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(bool __i) noexcept : _M_base(__i) { } + + bool + operator=(bool __i) noexcept + { return _M_base.operator=(__i); } + + bool + operator=(bool __i) volatile noexcept + { return _M_base.operator=(__i); } + + operator bool() const noexcept + { return _M_base.load(); } + + operator bool() const volatile noexcept + { return _M_base.load(); } + + bool + is_lock_free() const noexcept { return _M_base.is_lock_free(); } + + bool + is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); } + + void + store(bool __i, memory_order __m = memory_order_seq_cst) noexcept + { _M_base.store(__i, __m); } + + void + store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept + { _M_base.store(__i, __m); } + + bool + load(memory_order __m = memory_order_seq_cst) const noexcept + { return _M_base.load(__m); } + + bool + load(memory_order __m = memory_order_seq_cst) const volatile noexcept + { return _M_base.load(__m); } + + bool + exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept + { return _M_base.exchange(__i, __m); } + + bool + exchange(bool __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return _M_base.exchange(__i, __m); } + + bool + compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, + memory_order __m2) noexcept + { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } + + bool + compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, + memory_order __m2) volatile noexcept + { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } + + bool + compare_exchange_weak(bool& __i1, bool __i2, + memory_order __m = memory_order_seq_cst) noexcept + { return _M_base.compare_exchange_weak(__i1, __i2, __m); } + + bool + compare_exchange_weak(bool& __i1, bool __i2, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return _M_base.compare_exchange_weak(__i1, __i2, __m); } + + bool + compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, + memory_order __m2) noexcept + { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } + + bool + compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, + memory_order __m2) volatile noexcept + { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } + + bool + compare_exchange_strong(bool& __i1, bool __i2, + memory_order __m = memory_order_seq_cst) noexcept + { return _M_base.compare_exchange_strong(__i1, __i2, __m); } + + bool + compare_exchange_strong(bool& __i1, bool __i2, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return _M_base.compare_exchange_strong(__i1, __i2, __m); } + }; + + + + + + + + template + struct atomic + { + private: + + static constexpr int _S_min_alignment + = (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16 + ? 0 : sizeof(_Tp); + + static constexpr int _S_alignment + = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp); + + alignas(_S_alignment) _Tp _M_i; + + static_assert(__is_trivially_copyable(_Tp), + "std::atomic requires a trivially copyable type"); + + static_assert(sizeof(_Tp) > 0, + "Incomplete or zero-sized types are not supported"); + + public: + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(_Tp __i) noexcept : _M_i(__i) { } + + operator _Tp() const noexcept + { return load(); } + + operator _Tp() const volatile noexcept + { return load(); } + + _Tp + operator=(_Tp __i) noexcept + { store(__i); return __i; } + + _Tp + operator=(_Tp __i) volatile noexcept + { store(__i); return __i; } + + bool + is_lock_free() const noexcept + { + + return __atomic_is_lock_free(sizeof(_M_i), + reinterpret_cast(-__alignof(_M_i))); + } + + bool + is_lock_free() const volatile noexcept + { + + return __atomic_is_lock_free(sizeof(_M_i), + reinterpret_cast(-__alignof(_M_i))); + } + + void + store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept + { __atomic_store(&_M_i, &__i, __m); } + + void + store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept + { __atomic_store(&_M_i, &__i, __m); } + + _Tp + load(memory_order __m = memory_order_seq_cst) const noexcept + { + _Tp tmp; + __atomic_load(&_M_i, &tmp, __m); + return tmp; + } + + _Tp + load(memory_order __m = memory_order_seq_cst) const volatile noexcept + { + _Tp tmp; + __atomic_load(&_M_i, &tmp, __m); + return tmp; + } + + _Tp + exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept + { + _Tp tmp; + __atomic_exchange(&_M_i, &__i, &tmp, __m); + return tmp; + } + + _Tp + exchange(_Tp __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + _Tp tmp; + __atomic_exchange(&_M_i, &__i, &tmp, __m); + return tmp; + } + + bool + compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, + memory_order __f) noexcept + { + return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f); + } + + bool + compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, + memory_order __f) volatile noexcept + { + return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f); + } + + bool + compare_exchange_weak(_Tp& __e, _Tp __i, + memory_order __m = memory_order_seq_cst) noexcept + { return compare_exchange_weak(__e, __i, __m, + __cmpexch_failure_order(__m)); } + + bool + compare_exchange_weak(_Tp& __e, _Tp __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return compare_exchange_weak(__e, __i, __m, + __cmpexch_failure_order(__m)); } + + bool + compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, + memory_order __f) noexcept + { + return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f); + } + + bool + compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, + memory_order __f) volatile noexcept + { + return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f); + } + + bool + compare_exchange_strong(_Tp& __e, _Tp __i, + memory_order __m = memory_order_seq_cst) noexcept + { return compare_exchange_strong(__e, __i, __m, + __cmpexch_failure_order(__m)); } + + bool + compare_exchange_strong(_Tp& __e, _Tp __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return compare_exchange_strong(__e, __i, __m, + __cmpexch_failure_order(__m)); } + }; + + + + template + struct atomic<_Tp*> + { + typedef _Tp* __pointer_type; + typedef __atomic_base<_Tp*> __base_type; + __base_type _M_b; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { } + + operator __pointer_type() const noexcept + { return __pointer_type(_M_b); } + + operator __pointer_type() const volatile noexcept + { return __pointer_type(_M_b); } + + __pointer_type + operator=(__pointer_type __p) noexcept + { return _M_b.operator=(__p); } + + __pointer_type + operator=(__pointer_type __p) volatile noexcept + { return _M_b.operator=(__p); } + + __pointer_type + operator++(int) noexcept + { return _M_b++; } + + __pointer_type + operator++(int) volatile noexcept + { return _M_b++; } + + __pointer_type + operator--(int) noexcept + { return _M_b--; } + + __pointer_type + operator--(int) volatile noexcept + { return _M_b--; } + + __pointer_type + operator++() noexcept + { return ++_M_b; } + + __pointer_type + operator++() volatile noexcept + { return ++_M_b; } + + __pointer_type + operator--() noexcept + { return --_M_b; } + + __pointer_type + operator--() volatile noexcept + { return --_M_b; } + + __pointer_type + operator+=(ptrdiff_t __d) noexcept + { return _M_b.operator+=(__d); } + + __pointer_type + operator+=(ptrdiff_t __d) volatile noexcept + { return _M_b.operator+=(__d); } + + __pointer_type + operator-=(ptrdiff_t __d) noexcept + { return _M_b.operator-=(__d); } + + __pointer_type + operator-=(ptrdiff_t __d) volatile noexcept + { return _M_b.operator-=(__d); } + + bool + is_lock_free() const noexcept + { return _M_b.is_lock_free(); } + + bool + is_lock_free() const volatile noexcept + { return _M_b.is_lock_free(); } + + void + store(__pointer_type __p, + memory_order __m = memory_order_seq_cst) noexcept + { return _M_b.store(__p, __m); } + + void + store(__pointer_type __p, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return _M_b.store(__p, __m); } + + __pointer_type + load(memory_order __m = memory_order_seq_cst) const noexcept + { return _M_b.load(__m); } + + __pointer_type + load(memory_order __m = memory_order_seq_cst) const volatile noexcept + { return _M_b.load(__m); } + + __pointer_type + exchange(__pointer_type __p, + memory_order __m = memory_order_seq_cst) noexcept + { return _M_b.exchange(__p, __m); } + + __pointer_type + exchange(__pointer_type __p, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return _M_b.exchange(__p, __m); } + + bool + compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, memory_order __m2) noexcept + { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } + + bool + compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, + memory_order __m2) volatile noexcept + { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } + + bool + compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, + memory_order __m = memory_order_seq_cst) noexcept + { + return compare_exchange_weak(__p1, __p2, __m, + __cmpexch_failure_order(__m)); + } + + bool + compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return compare_exchange_weak(__p1, __p2, __m, + __cmpexch_failure_order(__m)); + } + + bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, memory_order __m2) noexcept + { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } + + bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, + memory_order __m2) volatile noexcept + { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } + + bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m = memory_order_seq_cst) noexcept + { + return _M_b.compare_exchange_strong(__p1, __p2, __m, + __cmpexch_failure_order(__m)); + } + + bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return _M_b.compare_exchange_strong(__p1, __p2, __m, + __cmpexch_failure_order(__m)); + } + + __pointer_type + fetch_add(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) noexcept + { return _M_b.fetch_add(__d, __m); } + + __pointer_type + fetch_add(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return _M_b.fetch_add(__d, __m); } + + __pointer_type + fetch_sub(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) noexcept + { return _M_b.fetch_sub(__d, __m); } + + __pointer_type + fetch_sub(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return _M_b.fetch_sub(__d, __m); } + }; + + + + template<> + struct atomic : __atomic_base + { + typedef char __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + + template<> + struct atomic : __atomic_base + { + typedef signed char __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept= default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + + template<> + struct atomic : __atomic_base + { + typedef unsigned char __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept= default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + + template<> + struct atomic : __atomic_base + { + typedef short __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + + template<> + struct atomic : __atomic_base + { + typedef unsigned short __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + + template<> + struct atomic : __atomic_base + { + typedef int __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + + template<> + struct atomic : __atomic_base + { + typedef unsigned int __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + + template<> + struct atomic : __atomic_base + { + typedef long __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + + template<> + struct atomic : __atomic_base + { + typedef unsigned long __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + + template<> + struct atomic : __atomic_base + { + typedef long long __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + + template<> + struct atomic : __atomic_base + { + typedef unsigned long long __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + + template<> + struct atomic : __atomic_base + { + typedef wchar_t __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + + template<> + struct atomic : __atomic_base + { + typedef char16_t __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + + template<> + struct atomic : __atomic_base + { + typedef char32_t __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + + + typedef atomic atomic_bool; + + + typedef atomic atomic_char; + + + typedef atomic atomic_schar; + + + typedef atomic atomic_uchar; + + + typedef atomic atomic_short; + + + typedef atomic atomic_ushort; + + + typedef atomic atomic_int; + + + typedef atomic atomic_uint; + + + typedef atomic atomic_long; + + + typedef atomic atomic_ulong; + + + typedef atomic atomic_llong; + + + typedef atomic atomic_ullong; + + + typedef atomic atomic_wchar_t; + + + typedef atomic atomic_char16_t; + + + typedef atomic atomic_char32_t; + + + + typedef atomic atomic_int_least8_t; + + + typedef atomic atomic_uint_least8_t; + + + typedef atomic atomic_int_least16_t; + + + typedef atomic atomic_uint_least16_t; + + + typedef atomic atomic_int_least32_t; + + + typedef atomic atomic_uint_least32_t; + + + typedef atomic atomic_int_least64_t; + + + typedef atomic atomic_uint_least64_t; + + + + typedef atomic atomic_int_fast8_t; + + + typedef atomic atomic_uint_fast8_t; + + + typedef atomic atomic_int_fast16_t; + + + typedef atomic atomic_uint_fast16_t; + + + typedef atomic atomic_int_fast32_t; + + + typedef atomic atomic_uint_fast32_t; + + + typedef atomic atomic_int_fast64_t; + + + typedef atomic atomic_uint_fast64_t; + + + + typedef atomic atomic_intptr_t; + + + typedef atomic atomic_uintptr_t; + + + typedef atomic atomic_size_t; + + + typedef atomic atomic_intmax_t; + + + typedef atomic atomic_uintmax_t; + + + typedef atomic atomic_ptrdiff_t; + + + + inline bool + atomic_flag_test_and_set_explicit(atomic_flag* __a, + memory_order __m) noexcept + { return __a->test_and_set(__m); } + + inline bool + atomic_flag_test_and_set_explicit(volatile atomic_flag* __a, + memory_order __m) noexcept + { return __a->test_and_set(__m); } + + inline void + atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept + { __a->clear(__m); } + + inline void + atomic_flag_clear_explicit(volatile atomic_flag* __a, + memory_order __m) noexcept + { __a->clear(__m); } + + inline bool + atomic_flag_test_and_set(atomic_flag* __a) noexcept + { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } + + inline bool + atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept + { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_flag_clear(atomic_flag* __a) noexcept + { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_flag_clear(volatile atomic_flag* __a) noexcept + { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } + + + + template + inline bool + atomic_is_lock_free(const atomic<_ITp>* __a) noexcept + { return __a->is_lock_free(); } + + template + inline bool + atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept + { return __a->is_lock_free(); } + + template + inline void + atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept + { __a->store(__i, memory_order_relaxed); } + + template + inline void + atomic_init(volatile atomic<_ITp>* __a, _ITp __i) noexcept + { __a->store(__i, memory_order_relaxed); } + + template + inline void + atomic_store_explicit(atomic<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { __a->store(__i, __m); } + + template + inline void + atomic_store_explicit(volatile atomic<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { __a->store(__i, __m); } + + template + inline _ITp + atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept + { return __a->load(__m); } + + template + inline _ITp + atomic_load_explicit(const volatile atomic<_ITp>* __a, + memory_order __m) noexcept + { return __a->load(__m); } + + template + inline _ITp + atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->exchange(__i, __m); } + + template + inline _ITp + atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->exchange(__i, __m); } + + template + inline bool + atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2, + memory_order __m1, + memory_order __m2) noexcept + { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } + + template + inline bool + atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2, + memory_order __m1, + memory_order __m2) noexcept + { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } + + template + inline bool + atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2, + memory_order __m1, + memory_order __m2) noexcept + { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } + + template + inline bool + atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2, + memory_order __m1, + memory_order __m2) noexcept + { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } + + + template + inline void + atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept + { atomic_store_explicit(__a, __i, memory_order_seq_cst); } + + template + inline void + atomic_store(volatile atomic<_ITp>* __a, _ITp __i) noexcept + { atomic_store_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_load(const atomic<_ITp>* __a) noexcept + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + template + inline _ITp + atomic_load(const volatile atomic<_ITp>* __a) noexcept + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + template + inline _ITp + atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept + { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i) noexcept + { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } + + template + inline bool + atomic_compare_exchange_weak(atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2) noexcept + { + return atomic_compare_exchange_weak_explicit(__a, __i1, __i2, + memory_order_seq_cst, + memory_order_seq_cst); + } + + template + inline bool + atomic_compare_exchange_weak(volatile atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2) noexcept + { + return atomic_compare_exchange_weak_explicit(__a, __i1, __i2, + memory_order_seq_cst, + memory_order_seq_cst); + } + + template + inline bool + atomic_compare_exchange_strong(atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2) noexcept + { + return atomic_compare_exchange_strong_explicit(__a, __i1, __i2, + memory_order_seq_cst, + memory_order_seq_cst); + } + + template + inline bool + atomic_compare_exchange_strong(volatile atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2) noexcept + { + return atomic_compare_exchange_strong_explicit(__a, __i1, __i2, + memory_order_seq_cst, + memory_order_seq_cst); + } + + + + + + template + inline _ITp + atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->fetch_add(__i, __m); } + + template + inline _ITp + atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->fetch_add(__i, __m); } + + template + inline _ITp + atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->fetch_sub(__i, __m); } + + template + inline _ITp + atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->fetch_sub(__i, __m); } + + template + inline _ITp + atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->fetch_and(__i, __m); } + + template + inline _ITp + atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->fetch_and(__i, __m); } + + template + inline _ITp + atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->fetch_or(__i, __m); } + + template + inline _ITp + atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->fetch_or(__i, __m); } + + template + inline _ITp + atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->fetch_xor(__i, __m); } + + template + inline _ITp + atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->fetch_xor(__i, __m); } + + template + inline _ITp + atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept + { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept + { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept + { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept + { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept + { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept + { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept + { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept + { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept + { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept + { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } + + + + template + inline _ITp* + atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d, + memory_order __m) noexcept + { return __a->fetch_add(__d, __m); } + + template + inline _ITp* + atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d, + memory_order __m) noexcept + { return __a->fetch_add(__d, __m); } + + template + inline _ITp* + atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept + { return __a->fetch_add(__d); } + + template + inline _ITp* + atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept + { return __a->fetch_add(__d); } + + template + inline _ITp* + atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a, + ptrdiff_t __d, memory_order __m) noexcept + { return __a->fetch_sub(__d, __m); } + + template + inline _ITp* + atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d, + memory_order __m) noexcept + { return __a->fetch_sub(__d, __m); } + + template + inline _ITp* + atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept + { return __a->fetch_sub(__d); } + + template + inline _ITp* + atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept + { return __a->fetch_sub(__d); } + + + +} +# 171 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h" 2 + +namespace mozilla { +namespace detail { + + + + + +template struct AtomicOrderConstraints; + +template<> +struct AtomicOrderConstraints +{ + static const std::memory_order AtomicRMWOrder = std::memory_order_relaxed; + static const std::memory_order LoadOrder = std::memory_order_relaxed; + static const std::memory_order StoreOrder = std::memory_order_relaxed; + static const std::memory_order CompareExchangeFailureOrder = + std::memory_order_relaxed; +}; + +template<> +struct AtomicOrderConstraints +{ + static const std::memory_order AtomicRMWOrder = std::memory_order_acq_rel; + static const std::memory_order LoadOrder = std::memory_order_acquire; + static const std::memory_order StoreOrder = std::memory_order_release; + static const std::memory_order CompareExchangeFailureOrder = + std::memory_order_acquire; +}; + +template<> +struct AtomicOrderConstraints +{ + static const std::memory_order AtomicRMWOrder = std::memory_order_seq_cst; + static const std::memory_order LoadOrder = std::memory_order_seq_cst; + static const std::memory_order StoreOrder = std::memory_order_seq_cst; + static const std::memory_order CompareExchangeFailureOrder = + std::memory_order_seq_cst; +}; + +template +struct IntrinsicBase +{ + typedef std::atomic ValueType; + typedef AtomicOrderConstraints OrderedOp; +}; + +template +struct IntrinsicMemoryOps : public IntrinsicBase +{ + typedef IntrinsicBase Base; + + static T load(const typename Base::ValueType& aPtr) + { + return aPtr.load(Base::OrderedOp::LoadOrder); + } + + static void store(typename Base::ValueType& aPtr, T aVal) + { + aPtr.store(aVal, Base::OrderedOp::StoreOrder); + } + + static T exchange(typename Base::ValueType& aPtr, T aVal) + { + return aPtr.exchange(aVal, Base::OrderedOp::AtomicRMWOrder); + } + + static bool compareExchange(typename Base::ValueType& aPtr, + T aOldVal, T aNewVal) + { + return aPtr.compare_exchange_strong(aOldVal, aNewVal, + Base::OrderedOp::AtomicRMWOrder, + Base::OrderedOp::CompareExchangeFailureOrder); + } +}; + +template +struct IntrinsicAddSub : public IntrinsicBase +{ + typedef IntrinsicBase Base; + + static T add(typename Base::ValueType& aPtr, T aVal) + { + return aPtr.fetch_add(aVal, Base::OrderedOp::AtomicRMWOrder); + } + + static T sub(typename Base::ValueType& aPtr, T aVal) + { + return aPtr.fetch_sub(aVal, Base::OrderedOp::AtomicRMWOrder); + } +}; + +template +struct IntrinsicAddSub : public IntrinsicBase +{ + typedef IntrinsicBase Base; + + static T* add(typename Base::ValueType& aPtr, ptrdiff_t aVal) + { + return aPtr.fetch_add(aVal, Base::OrderedOp::AtomicRMWOrder); + } + + static T* sub(typename Base::ValueType& aPtr, ptrdiff_t aVal) + { + return aPtr.fetch_sub(aVal, Base::OrderedOp::AtomicRMWOrder); + } +}; + +template +struct IntrinsicIncDec : public IntrinsicAddSub +{ + typedef IntrinsicBase Base; + + static T inc(typename Base::ValueType& aPtr) + { + return IntrinsicAddSub::add(aPtr, 1); + } + + static T dec(typename Base::ValueType& aPtr) + { + return IntrinsicAddSub::sub(aPtr, 1); + } +}; + +template +struct AtomicIntrinsics : public IntrinsicMemoryOps, + public IntrinsicIncDec +{ + typedef IntrinsicBase Base; + + static T or_(typename Base::ValueType& aPtr, T aVal) + { + return aPtr.fetch_or(aVal, Base::OrderedOp::AtomicRMWOrder); + } + + static T xor_(typename Base::ValueType& aPtr, T aVal) + { + return aPtr.fetch_xor(aVal, Base::OrderedOp::AtomicRMWOrder); + } + + static T and_(typename Base::ValueType& aPtr, T aVal) + { + return aPtr.fetch_and(aVal, Base::OrderedOp::AtomicRMWOrder); + } +}; + +template +struct AtomicIntrinsics + : public IntrinsicMemoryOps, public IntrinsicIncDec +{ +}; + +template +struct ToStorageTypeArgument +{ + static constexpr T convert (T aT) { return aT; } +}; + +} +} +# 533 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h" +namespace mozilla { + +namespace detail { + +template +class AtomicBase +{ + static_assert(sizeof(T) == 4 || sizeof(T) == 8, + "mozilla/Atomics.h only supports 32-bit and 64-bit types"); + +protected: + typedef typename detail::AtomicIntrinsics Intrinsics; + typedef typename Intrinsics::ValueType ValueType; + ValueType mValue; + +public: + constexpr AtomicBase() : mValue() {} + explicit constexpr AtomicBase(T aInit) + : mValue(ToStorageTypeArgument::convert(aInit)) + {} + + + + + + + T operator=(T aVal) + { + Intrinsics::store(mValue, aVal); + return aVal; + } + + + + + + T exchange(T aVal) + { + return Intrinsics::exchange(mValue, aVal); + } +# 585 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h" + bool compareExchange(T aOldValue, T aNewValue) + { + return Intrinsics::compareExchange(mValue, aOldValue, aNewValue); + } + +private: + template + AtomicBase(const AtomicBase& aCopy) = delete; +}; + +template +class AtomicBaseIncDec : public AtomicBase +{ + typedef typename detail::AtomicBase Base; + +public: + constexpr AtomicBaseIncDec() : Base() {} + explicit constexpr AtomicBaseIncDec(T aInit) : Base(aInit) {} + + using Base::operator=; + + operator T() const { return Base::Intrinsics::load(Base::mValue); } + T operator++(int) { return Base::Intrinsics::inc(Base::mValue); } + T operator--(int) { return Base::Intrinsics::dec(Base::mValue); } + T operator++() { return Base::Intrinsics::inc(Base::mValue) + 1; } + T operator--() { return Base::Intrinsics::dec(Base::mValue) - 1; } + +private: + template + AtomicBaseIncDec(const AtomicBaseIncDec& aCopy) = delete; +}; + +} +# 636 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h" +template +class Atomic; +# 649 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h" +template +class Atomic::value && + !IsSame::value>::Type> + : public detail::AtomicBaseIncDec +{ + typedef typename detail::AtomicBaseIncDec Base; + +public: + constexpr Atomic() : Base() {} + explicit constexpr Atomic(T aInit) : Base(aInit) {} + + using Base::operator=; + + T operator+=(T aDelta) + { + return Base::Intrinsics::add(Base::mValue, aDelta) + aDelta; + } + + T operator-=(T aDelta) + { + return Base::Intrinsics::sub(Base::mValue, aDelta) - aDelta; + } + + T operator|=(T aVal) + { + return Base::Intrinsics::or_(Base::mValue, aVal) | aVal; + } + + T operator^=(T aVal) + { + return Base::Intrinsics::xor_(Base::mValue, aVal) ^ aVal; + } + + T operator&=(T aVal) + { + return Base::Intrinsics::and_(Base::mValue, aVal) & aVal; + } + +private: + Atomic(Atomic& aOther) = delete; +}; +# 699 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h" +template +class Atomic : public detail::AtomicBaseIncDec +{ + typedef typename detail::AtomicBaseIncDec Base; + +public: + constexpr Atomic() : Base() {} + explicit constexpr Atomic(T* aInit) : Base(aInit) {} + + using Base::operator=; + + T* operator+=(ptrdiff_t aDelta) + { + return Base::Intrinsics::add(Base::mValue, aDelta) + aDelta; + } + + T* operator-=(ptrdiff_t aDelta) + { + return Base::Intrinsics::sub(Base::mValue, aDelta) - aDelta; + } + +private: + Atomic(Atomic& aOther) = delete; +}; + + + + + + +template +class Atomic::value>::Type> + : public detail::AtomicBase +{ + typedef typename detail::AtomicBase Base; + +public: + constexpr Atomic() : Base() {} + explicit constexpr Atomic(T aInit) : Base(aInit) {} + + operator T() const { return T(Base::Intrinsics::load(Base::mValue)); } + + using Base::operator=; + +private: + Atomic(Atomic& aOther) = delete; +}; +# 763 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h" +template +class Atomic + : protected detail::AtomicBase +{ + typedef typename detail::AtomicBase Base; + +public: + constexpr Atomic() : Base() {} + explicit constexpr Atomic(bool aInit) : Base(aInit) {} + + + operator bool() const + { + return Base::Intrinsics::load(Base::mValue); + } + + bool operator=(bool aVal) + { + return Base::operator=(aVal); + } + + bool exchange(bool aVal) + { + return Base::exchange(aVal); + } + + bool compareExchange(bool aOldValue, bool aNewValue) + { + return Base::compareExchange(aOldValue, aNewValue); + } + +private: + Atomic(Atomic& aOther) = delete; +}; + +} +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" 2 + + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h" 1 +# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/GuardObjects.h" 1 +# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h" 2 + + +namespace mozilla { +# 67 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h" +template +class Scoped +{ +public: + typedef typename Traits::type Resource; + + explicit Scoped() + : mValue(Traits::empty()) + { + do { } while (0); + } + + explicit Scoped(const Resource& aValue + ) + : mValue(aValue) + { + do { } while (0); + } + + + Scoped(Scoped&& aOther + ) + : mValue(Move(aOther.mValue)) + { + do { } while (0); + aOther.mValue = Traits::empty(); + } + + ~Scoped() { Traits::release(mValue); } + + + operator const Resource&() const { return mValue; } + const Resource& operator->() const { return mValue; } + const Resource& get() const { return mValue; } + + Resource& rwget() { return mValue; } +# 113 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h" + Resource forget() + { + Resource tmp = mValue; + mValue = Traits::empty(); + return tmp; + } + + + + + + + void dispose() + { + Traits::release(mValue); + mValue = Traits::empty(); + } + + bool operator==(const Resource& aOther) const { return mValue == aOther; } +# 141 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h" + Scoped& operator=(const Resource& aOther) { return reset(aOther); } + + Scoped& reset(const Resource& aOther) + { + Traits::release(mValue); + mValue = aOther; + return *this; + } + + + Scoped& operator=(Scoped&& aRhs) + { + do { } while (0); + this->~Scoped(); + new(this) Scoped(Move(aRhs)); + return *this; + } + +private: + explicit Scoped(const Scoped& aValue) = delete; + Scoped& operator=(const Scoped& aValue) = delete; + +private: + Resource mValue; + +}; +# 236 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h" +template void TypeSpecificDelete(T* aValue); + +template +struct TypeSpecificScopedPointerTraits +{ + typedef T* type; + static type empty() { return nullptr; } + static void release(type aValue) + { + if (aValue) { + TypeSpecificDelete(aValue); + } + } +}; + +template struct TypeSpecificScopedPointer : public mozilla::Scoped > { typedef mozilla::Scoped > Super; typedef typename Super::Resource Resource; TypeSpecificScopedPointer& operator=(Resource aRhs) { Super::operator=(aRhs); return *this; } TypeSpecificScopedPointer& operator=(TypeSpecificScopedPointer&& aRhs) { Super::operator=(Move(aRhs)); return *this; } explicit TypeSpecificScopedPointer() : Super() {} explicit TypeSpecificScopedPointer(Resource aRhs ) : Super(aRhs ) {} TypeSpecificScopedPointer(TypeSpecificScopedPointer&& aRhs ) : Super(Move(aRhs) ) {} private: explicit TypeSpecificScopedPointer(TypeSpecificScopedPointer&) = delete; TypeSpecificScopedPointer& operator=(TypeSpecificScopedPointer&) = delete; }; + +} +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" 2 + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3 +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" 2 +# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" +namespace JS {} + + +namespace mozilla {} + + +namespace js {} + + + + +extern __attribute__((noreturn)) __attribute__ ((cold)) void +JS_Assert(const char* s, const char* file, int ln); +# 51 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" +namespace js { +namespace oom { + + + + + + + +enum ThreadType { + THREAD_TYPE_NONE = 0, + THREAD_TYPE_COOPERATING, + THREAD_TYPE_WASM, + THREAD_TYPE_ION, + THREAD_TYPE_PARSE, + THREAD_TYPE_COMPRESS, + THREAD_TYPE_GCHELPER, + THREAD_TYPE_GCPARALLEL, + THREAD_TYPE_PROMISE_TASK, + THREAD_TYPE_MAX +}; +# 82 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" +inline bool InitThreadType(void) { return true; } +inline void SetThreadType(ThreadType t) {}; +inline uint32_t GetThreadType(void) { return 0; } + + +} +} +# 169 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" +namespace js { +namespace oom { +static inline bool IsSimulatedOOMAllocation() { return false; } +static inline bool ShouldFailWithOOM() { return false; } +} +} + + + +namespace js { + + +struct AutoEnterOOMUnsafeRegion +{ + __attribute__((noreturn)) __attribute__ ((cold)) void crash(const char* reason); + __attribute__((noreturn)) __attribute__ ((cold)) void crash(size_t size, const char* reason); + + using AnnotateOOMAllocationSizeCallback = void(*)(size_t); + static AnnotateOOMAllocationSizeCallback annotateOOMSizeCallback; + static void setAnnotateOOMAllocationSizeCallback(AnnotateOOMAllocationSizeCallback callback) { + annotateOOMSizeCallback = callback; + } +# 222 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" +}; + +} + +static inline void* js_malloc(size_t bytes) +{ + do {} while(0); + return malloc(bytes); +} + +static inline void* js_calloc(size_t bytes) +{ + do {} while(0); + return calloc(bytes, 1); +} + +static inline void* js_calloc(size_t nmemb, size_t size) +{ + do {} while(0); + return calloc(nmemb, size); +} + +static inline void* js_realloc(void* p, size_t bytes) +{ + + + + do { } while (0); + + do {} while(0); + return realloc(p, bytes); +} + +static inline void js_free(void* p) +{ + free(p); +} + +static inline char* js_strdup(const char* s) +{ + do {} while(0); + return strdup(s); +} +# 346 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" +template static __attribute__((always_inline)) inline T * js_new(Args&&... args) { void* memory = js_malloc(sizeof(T)); return (__builtin_expect(!!(memory), 1)) ? new(memory) T(mozilla::Forward(args)...) : nullptr; } + +namespace js { + + + + + +template +__attribute__ ((warn_unused_result)) inline bool +CalculateAllocSize(size_t numElems, size_t* bytesOut) +{ + *bytesOut = numElems * sizeof(T); + return (numElems & mozilla::tl::MulOverflowMask::value) == 0; +} + + + + + + +template +__attribute__ ((warn_unused_result)) inline bool +CalculateAllocSizeWithExtra(size_t numExtra, size_t* bytesOut) +{ + *bytesOut = sizeof(T) + numExtra * sizeof(Extra); + return (numExtra & mozilla::tl::MulOverflowMask::value) == 0 && + *bytesOut >= sizeof(T); +} + +} + +template +static __attribute__((always_inline)) inline void +js_delete(const T* p) +{ + if (p) { + p->~T(); + js_free(const_cast(p)); + } +} + +template +static __attribute__((always_inline)) inline void +js_delete_poison(const T* p) +{ + if (p) { + p->~T(); + memset(const_cast(p), 0x3B, sizeof(T)); + js_free(const_cast(p)); + } +} + +template +static __attribute__((always_inline)) inline T* +js_pod_malloc() +{ + return static_cast(js_malloc(sizeof(T))); +} + +template +static __attribute__((always_inline)) inline T* +js_pod_calloc() +{ + return static_cast(js_calloc(sizeof(T))); +} + +template +static __attribute__((always_inline)) inline T* +js_pod_malloc(size_t numElems) +{ + size_t bytes; + if ((__builtin_expect(!!(!js::CalculateAllocSize(numElems, &bytes)), 0))) + return nullptr; + return static_cast(js_malloc(bytes)); +} + +template +static __attribute__((always_inline)) inline T* +js_pod_calloc(size_t numElems) +{ + size_t bytes; + if ((__builtin_expect(!!(!js::CalculateAllocSize(numElems, &bytes)), 0))) + return nullptr; + return static_cast(js_calloc(bytes)); +} + +template +static __attribute__((always_inline)) inline T* +js_pod_realloc(T* prior, size_t oldSize, size_t newSize) +{ + do { } while (0); + size_t bytes; + if ((__builtin_expect(!!(!js::CalculateAllocSize(newSize, &bytes)), 0))) + return nullptr; + return static_cast(js_realloc(prior, bytes)); +} + +namespace js { + +template +struct ScopedFreePtrTraits +{ + typedef T* type; + static T* empty() { return nullptr; } + static void release(T* ptr) { js_free(ptr); } +}; +template struct ScopedJSFreePtr : public mozilla::Scoped > { typedef mozilla::Scoped > Super; typedef typename Super::Resource Resource; ScopedJSFreePtr& operator=(Resource aRhs) { Super::operator=(aRhs); return *this; } ScopedJSFreePtr& operator=(ScopedJSFreePtr&& aRhs) { Super::operator=(Move(aRhs)); return *this; } explicit ScopedJSFreePtr() : Super() {} explicit ScopedJSFreePtr(Resource aRhs ) : Super(aRhs ) {} ScopedJSFreePtr(ScopedJSFreePtr&& aRhs ) : Super(Move(aRhs) ) {} private: explicit ScopedJSFreePtr(ScopedJSFreePtr&) = delete; ScopedJSFreePtr& operator=(ScopedJSFreePtr&) = delete; }; + +template +struct ScopedDeletePtrTraits : public ScopedFreePtrTraits +{ + static void release(T* ptr) { js_delete(ptr); } +}; +template struct ScopedJSDeletePtr : public mozilla::Scoped > { typedef mozilla::Scoped > Super; typedef typename Super::Resource Resource; ScopedJSDeletePtr& operator=(Resource aRhs) { Super::operator=(aRhs); return *this; } ScopedJSDeletePtr& operator=(ScopedJSDeletePtr&& aRhs) { Super::operator=(Move(aRhs)); return *this; } explicit ScopedJSDeletePtr() : Super() {} explicit ScopedJSDeletePtr(Resource aRhs ) : Super(aRhs ) {} ScopedJSDeletePtr(ScopedJSDeletePtr&& aRhs ) : Super(Move(aRhs) ) {} private: explicit ScopedJSDeletePtr(ScopedJSDeletePtr&) = delete; ScopedJSDeletePtr& operator=(ScopedJSDeletePtr&) = delete; }; + +template +struct ScopedReleasePtrTraits : public ScopedFreePtrTraits +{ + static void release(T* ptr) { if (ptr) ptr->release(); } +}; +template struct ScopedReleasePtr : public mozilla::Scoped > { typedef mozilla::Scoped > Super; typedef typename Super::Resource Resource; ScopedReleasePtr& operator=(Resource aRhs) { Super::operator=(aRhs); return *this; } ScopedReleasePtr& operator=(ScopedReleasePtr&& aRhs) { Super::operator=(Move(aRhs)); return *this; } explicit ScopedReleasePtr() : Super() {} explicit ScopedReleasePtr(Resource aRhs ) : Super(aRhs ) {} ScopedReleasePtr(ScopedReleasePtr&& aRhs ) : Super(Move(aRhs) ) {} private: explicit ScopedReleasePtr(ScopedReleasePtr&) = delete; ScopedReleasePtr& operator=(ScopedReleasePtr&) = delete; }; + +} + +namespace JS { + +template +struct DeletePolicy +{ + constexpr DeletePolicy() {} + + template + DeletePolicy(DeletePolicy other, + typename mozilla::EnableIf::value, + int>::Type dummy = 0) + {} + + void operator()(const T* ptr) { + js_delete(const_cast(ptr)); + } +}; + +struct FreePolicy +{ + void operator()(const void* ptr) { + js_free(const_cast(ptr)); + } +}; + +typedef mozilla::UniquePtr UniqueChars; +typedef mozilla::UniquePtr UniqueTwoByteChars; + +} + +namespace js { + + +typedef uint32_t HashNumber; +const unsigned HashNumberSizeBits = 32; + +namespace detail { +# 524 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" +inline HashNumber +ScrambleHashCode(HashNumber h) +{ +# 542 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" + static const HashNumber goldenRatio = 0x9E3779B9U; + return h * goldenRatio; +} + +} + +} +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HeapAPI.h" 2 + + +namespace js { + +bool +CurrentThreadCanAccessZone(JS::Zone* zone); + +namespace gc { + +struct Cell; + +const size_t ArenaShift = 12; +const size_t ArenaSize = size_t(1) << ArenaShift; +const size_t ArenaMask = ArenaSize - 1; + + + + +const size_t ChunkShift = 20; + +const size_t ChunkSize = size_t(1) << ChunkShift; +const size_t ChunkMask = ChunkSize - 1; + +const size_t CellShift = 3; +const size_t CellSize = size_t(1) << CellShift; +const size_t CellMask = CellSize - 1; + + + + + + +const size_t ChunkMarkBitmapOffset = 1032352; +const size_t ChunkMarkBitmapBits = 129024; + +const size_t ChunkRuntimeOffset = ChunkSize - sizeof(void*); +const size_t ChunkTrailerSize = 2 * sizeof(uintptr_t) + sizeof(uint64_t); +const size_t ChunkLocationOffset = ChunkSize - ChunkTrailerSize; +const size_t ArenaZoneOffset = sizeof(size_t); +const size_t ArenaHeaderSize = sizeof(size_t) + 2 * sizeof(uintptr_t) + + sizeof(size_t) + sizeof(uintptr_t); + + + + + + +static const uint32_t BLACK = 0; +static const uint32_t GRAY = 1; + + + + + +enum class ChunkLocation : uint32_t +{ + Invalid = 0, + Nursery = 1, + TenuredHeap = 2 +}; + + + +extern void +AssertGCThingHasType(js::gc::Cell* cell, JS::TraceKind kind); + + + + + +__attribute__((always_inline)) inline bool IsInsideNursery(const js::gc::Cell* cell); + +} +} + +namespace JS { +struct Zone; + + +const uint32_t DefaultNurseryBytes = 16 * js::gc::ChunkSize; + + +const uint32_t DefaultHeapMaxBytes = 32 * 1024 * 1024; + +namespace shadow { + +struct Zone +{ + protected: + JSRuntime* const runtime_; + JSTracer* const barrierTracer_; + + public: + bool needsIncrementalBarrier_; + + Zone(JSRuntime* runtime, JSTracer* barrierTracerArg) + : runtime_(runtime), + barrierTracer_(barrierTracerArg), + needsIncrementalBarrier_(false) + {} + + bool needsIncrementalBarrier() const { + return needsIncrementalBarrier_; + } + + JSTracer* barrierTracer() { + do { } while (0); + do { } while (0); + return barrierTracer_; + } + + JSRuntime* runtimeFromActiveCooperatingThread() const { + do { } while (0); + return runtime_; + } + + + + JSRuntime* runtimeFromAnyThread() const { + return runtime_; + } + + static __attribute__((always_inline)) inline JS::shadow::Zone* asShadowZone(JS::Zone* zone) { + return reinterpret_cast(zone); + } +}; + +} +# 152 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HeapAPI.h" +class GCCellPtr +{ + public: + + GCCellPtr(void* gcthing, JS::TraceKind traceKind) : ptr(checkedCast(gcthing, traceKind)) {} + + + GCCellPtr(decltype(nullptr)) : ptr(checkedCast(nullptr, JS::TraceKind::Null)) {} + + + template + explicit GCCellPtr(T* p) : ptr(checkedCast(p, JS::MapTypeToTraceKind::kind)) { } + explicit GCCellPtr(JSFunction* p) : ptr(checkedCast(p, JS::TraceKind::Object)) { } + explicit GCCellPtr(JSFlatString* str) : ptr(checkedCast(str, JS::TraceKind::String)) { } + explicit GCCellPtr(const Value& v); + + JS::TraceKind kind() const { + JS::TraceKind traceKind = JS::TraceKind(ptr & OutOfLineTraceKindMask); + if (uintptr_t(traceKind) != OutOfLineTraceKindMask) + return traceKind; + return outOfLineKind(); + } + + + explicit operator bool() const { + do { } while (0); + return asCell(); + } + + + template + bool is() const { return kind() == JS::MapTypeToTraceKind::kind; } + + + + template + T& as() const { + do { } while (0); + + + return *reinterpret_cast(asCell()); + } + + + + + js::gc::Cell* asCell() const { + return reinterpret_cast(ptr & ~OutOfLineTraceKindMask); + } + + + uint64_t unsafeAsInteger() const { + return static_cast(unsafeAsUIntPtr()); + } + + uintptr_t unsafeAsUIntPtr() const { + do { } while (0); + do { } while (0); + return reinterpret_cast(asCell()); + } + + bool mayBeOwnedByOtherRuntime() const; + + private: + static uintptr_t checkedCast(void* p, JS::TraceKind traceKind) { + js::gc::Cell* cell = static_cast(p); + do { } while (0); + AssertGCThingHasType(cell, traceKind); + + + do { } while (0); + + return uintptr_t(p) | (uintptr_t(traceKind) & OutOfLineTraceKindMask); + } + + JS::TraceKind outOfLineKind() const; + + uintptr_t ptr; +}; + +inline bool +operator==(const GCCellPtr& ptr1, const GCCellPtr& ptr2) +{ + return ptr1.asCell() == ptr2.asCell(); +} + +inline bool +operator!=(const GCCellPtr& ptr1, const GCCellPtr& ptr2) +{ + return !(ptr1 == ptr2); +} + + + +template +auto +DispatchTyped(F f, GCCellPtr thing, Args&&... args) + -> decltype(f(static_cast(nullptr), mozilla::Forward(args)...)) +{ + switch (thing.kind()) { + + + + case JS::TraceKind::BaseShape: return f(&thing.as(), mozilla::Forward(args)...); case JS::TraceKind::JitCode: return f(&thing.as(), mozilla::Forward(args)...); case JS::TraceKind::LazyScript: return f(&thing.as(), mozilla::Forward(args)...); case JS::TraceKind::Scope: return f(&thing.as(), mozilla::Forward(args)...); case JS::TraceKind::Object: return f(&thing.as(), mozilla::Forward(args)...); case JS::TraceKind::ObjectGroup: return f(&thing.as(), mozilla::Forward(args)...); case JS::TraceKind::Script: return f(&thing.as(), mozilla::Forward(args)...); case JS::TraceKind::Shape: return f(&thing.as(), mozilla::Forward(args)...); case JS::TraceKind::String: return f(&thing.as(), mozilla::Forward(args)...); case JS::TraceKind::Symbol: return f(&thing.as(), mozilla::Forward(args)...); case JS::TraceKind::RegExpShared: return f(&thing.as(), mozilla::Forward(args)...);; + + default: + do { AnnotateMozCrashReason("MOZ_CRASH(" "Invalid trace kind in DispatchTyped for GCCellPtr." ")"); do { *((volatile int*) __null) = 258; ::abort(); } while (0); } while (0); + } +} + +} + +namespace js { +namespace gc { +namespace detail { + +static __attribute__((always_inline)) inline uintptr_t* +GetGCThingMarkBitmap(const uintptr_t addr) +{ + do { } while (0); + const uintptr_t bmap_addr = (addr & ~ChunkMask) | ChunkMarkBitmapOffset; + return reinterpret_cast(bmap_addr); +} + +static __attribute__((always_inline)) inline void +GetGCThingMarkWordAndMask(const uintptr_t addr, uint32_t color, + uintptr_t** wordp, uintptr_t* maskp) +{ + do { } while (0); + const size_t bit = (addr & js::gc::ChunkMask) / js::gc::CellSize + color; + do { } while (0); + uintptr_t* bitmap = GetGCThingMarkBitmap(addr); + const uintptr_t nbits = sizeof(*bitmap) * 8; + *maskp = uintptr_t(1) << (bit % nbits); + *wordp = &bitmap[bit / nbits]; +} + +static __attribute__((always_inline)) inline JS::Zone* +GetGCThingZone(const uintptr_t addr) +{ + do { } while (0); + const uintptr_t zone_addr = (addr & ~ArenaMask) | ArenaZoneOffset; + return *reinterpret_cast(zone_addr); + +} + +static __attribute__((always_inline)) inline bool +CellIsMarkedGray(const Cell* cell) +{ + do { } while (0); + if (js::gc::IsInsideNursery(cell)) + return false; + + uintptr_t* word, mask; + js::gc::detail::GetGCThingMarkWordAndMask(uintptr_t(cell), js::gc::GRAY, &word, &mask); + return *word & mask; +} + +extern bool +CellIsMarkedGrayIfKnown(const Cell* cell); + + + + + + +} + +__attribute__((always_inline)) inline bool +IsInsideNursery(const js::gc::Cell* cell) +{ + if (!cell) + return false; + uintptr_t addr = uintptr_t(cell); + addr &= ~js::gc::ChunkMask; + addr |= js::gc::ChunkLocationOffset; + auto location = *reinterpret_cast(addr); + do { } while (0); + return location == ChunkLocation::Nursery; +} + +} +} + +namespace JS { + +static __attribute__((always_inline)) inline Zone* +GetTenuredGCThingZone(GCCellPtr thing) +{ + do { } while (0); + return js::gc::detail::GetGCThingZone(thing.unsafeAsUIntPtr()); +} + +static __attribute__((always_inline)) inline Zone* +GetStringZone(JSString* str) +{ + return js::gc::detail::GetGCThingZone(uintptr_t(str)); +} + +extern Zone* +GetObjectZone(JSObject* obj); + +static __attribute__((always_inline)) inline bool +GCThingIsMarkedGray(GCCellPtr thing) +{ + if (thing.mayBeOwnedByOtherRuntime()) + return false; + return js::gc::detail::CellIsMarkedGrayIfKnown(thing.asCell()); +} + +extern JS::TraceKind +GCThingTraceKind(void* thing); + +} + +namespace js { +namespace gc { + +static __attribute__((always_inline)) inline bool +IsIncrementalBarrierNeededOnTenuredGCThing(const JS::GCCellPtr thing) +{ + do { } while (0); + do { } while (0); + + + + + do { } while (0); + + JS::Zone* zone = JS::GetTenuredGCThingZone(thing); + return JS::shadow::Zone::asShadowZone(zone)->needsIncrementalBarrier(); +} + + + + + + +extern JSObject* +NewMemoryInfoObject(JSContext* cx); + +} +} +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionTraversalCallback.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupports.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupports.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsrootidl.h" 1 +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsrootidl.h" +typedef int64_t PRTime; + + + +class nsAString; +class nsACString; +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupports.h" 2 +# 129 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupports.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsBase.h" 1 +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsBase.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsID.h" 1 +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsID.h" +struct nsID +{ + + + + + + uint32_t m0; + uint16_t m1; + uint16_t m2; + uint8_t m3[8]; +# 41 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsID.h" + void Clear(); + + + + + + + inline bool Equals(const nsID& aOther) const + { + + return + (((uint32_t*)&m0)[0] == ((uint32_t*)&aOther.m0)[0]) && + (((uint32_t*)&m0)[1] == ((uint32_t*)&aOther.m0)[1]) && + (((uint32_t*)&m0)[2] == ((uint32_t*)&aOther.m0)[2]) && + (((uint32_t*)&m0)[3] == ((uint32_t*)&aOther.m0)[3]); + } + + inline bool operator==(const nsID& aOther) const + { + return Equals(aOther); + } + + + + + + bool Parse(const char* aIDStr); + + + + + + + + char* ToString() const; + + + + + + + void ToProvidedString(char (&aDest)[39]) const; + + + + +}; +# 96 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsID.h" +class nsIDToCString +{ +public: + explicit nsIDToCString(const nsID& aID) + { + aID.ToProvidedString(mStringBytes); + } + + const char *get() const + { + return mStringBytes; + } + +protected: + char mStringBytes[39]; +}; + + + + + + +typedef nsID nsCID; +# 134 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsID.h" +typedef nsID nsIID; +# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsBase.h" 2 +# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsBase.h" +class nsISupports +{ +public: + + template struct COMTypeInfo; +# 59 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsBase.h" + virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) = 0; + + + + + + + + virtual MozExternalRefCountType AddRef(void) = 0; +# 76 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsBase.h" + virtual MozExternalRefCountType Release(void) = 0; + + +}; + +template struct nsISupports::COMTypeInfo { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template const nsIID nsISupports::COMTypeInfo::kIID __attribute__ ((visibility ("hidden"))) = { 0x00000000, 0x0000, 0x0000, {0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46} }; +# 130 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupports.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h" 1 +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h" 1 +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" 1 +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOMCID.h" 1 +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" 2 +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" +class nsAString; +class nsACString; + +class nsISupports; +class nsIModule; +class nsIComponentManager; +class nsIComponentRegistrar; +class nsIServiceManager; +class nsIFile; +class nsILocalFile; +class nsIDirectoryServiceProvider; +class nsIMemory; +class nsIDebug2; + + +namespace mozilla { +struct Module; +} +# 73 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" +extern "C" nsresult +NS_InitXPCOM2(nsIServiceManager** aResult, + nsIFile* aBinDirectory, + nsIDirectoryServiceProvider* aAppFileLocationProvider); + + + + + +extern "C" nsresult +NS_InitMinimalXPCOM(); +# 95 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" +extern "C" nsresult NS_ShutdownXPCOM(nsIServiceManager* aServMgr); +# 106 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" +extern "C" nsresult NS_GetServiceManager(nsIServiceManager** aResult); +# 116 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" +extern "C" nsresult NS_GetComponentManager(nsIComponentManager** aResult); +# 127 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" +extern "C" nsresult NS_GetComponentRegistrar(nsIComponentRegistrar** aResult); +# 137 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" +extern "C" nsresult NS_GetMemoryManager(nsIMemory** aResult); +# 162 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" +extern "C" nsresult NS_NewLocalFile(const nsAString& aPath, + bool aFollowLinks, + nsIFile** aResult); + +extern "C" nsresult NS_NewNativeLocalFile(const nsACString& aPath, + bool aFollowLinks, + nsIFile** aResult); + + + + +class NS_ConvertUTF16toUTF8; +nsresult NS_NewNativeLocalFile(const NS_ConvertUTF16toUTF8& aPath, + bool aFollowLinks, + nsIFile** aResult) = delete; +# 232 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" +enum +{ + NS_DEBUG_WARNING = 0, + NS_DEBUG_ASSERTION = 1, + NS_DEBUG_BREAK = 2, + NS_DEBUG_ABORT = 3 +}; +# 255 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" +extern "C" void NS_DebugBreak(uint32_t aSeverity, + const char* aStr, const char* aExpr, + const char* aFile, int32_t aLine); +# 275 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" +extern "C" void NS_LogInit(); + +extern "C" void NS_LogTerm(); + + + + + + + +class ScopedLogging +{ +public: + ScopedLogging() + { + NS_LogInit(); + } + + ~ScopedLogging() + { + NS_LogTerm(); + } +}; +# 310 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" +extern "C" void NS_LogCtor(void* aPtr, const char* aTypeName, + uint32_t aInstanceSize); + +extern "C" void NS_LogDtor(void* aPtr, const char* aTypeName, + uint32_t aInstanceSize); +# 326 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" +extern "C" void NS_LogAddRef(void* aPtr, nsrefcnt aNewRefCnt, + const char* aTypeName, uint32_t aInstanceSize); + +extern "C" void NS_LogRelease(void* aPtr, nsrefcnt aNewRefCnt, + const char* aTypeName); +# 342 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" +extern "C" void NS_LogCOMPtrAddRef(void* aCOMPtr, nsISupports* aObject); + +extern "C" void NS_LogCOMPtrRelease(void* aCOMPtr, nsISupports* aObject); +# 354 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" +class nsCycleCollectionParticipant; +class nsCycleCollectingAutoRefCnt; + +extern "C" void NS_CycleCollectorSuspect3(void* aPtr, + nsCycleCollectionParticipant* aCp, + nsCycleCollectingAutoRefCnt* aRefCnt, + bool* aShouldDelete); +# 439 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" +extern "C" nsresult NS_GetDebug(nsIDebug2** aResult); +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h" 2 +# 376 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h" +void NS_ABORT_OOM(size_t aSize); +# 390 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h" +extern "C" { +# 402 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h" +void printf_stderr(const char* aFmt, ...) __attribute__ ((format (printf, 1, 2))); + + + + +void vprintf_stderr(const char* aFmt, va_list aArgs); +# 424 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h" +void fprintf_stderr(FILE* aFile, const char* aFmt, ...) __attribute__ ((format (printf, 2, 3))); + + +} +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h" 1 +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h" 1 +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h" 2 + + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h" 1 +# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" 1 +# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prcpucfg.h" 1 +# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prcpucfg.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/md/_linux.cfg" 1 +# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prcpucfg.h" 2 +# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" 2 + + +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 +# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" 2 +# 206 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" +extern "C" { +# 246 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" +typedef unsigned char PRUint8; +# 260 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" +typedef signed char PRInt8; +# 285 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" +typedef unsigned short PRUint16; +typedef short PRInt16; +# 310 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" +typedef unsigned int PRUint32; +typedef int PRInt32; +# 365 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" +typedef long PRInt64; +typedef unsigned long PRUint64; +# 410 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" +typedef int PRIntn; +typedef unsigned int PRUintn; +# 421 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" +typedef double PRFloat64; + + + + + + +typedef size_t PRSize; + + + + + + + +typedef PRInt32 PROffset32; +typedef PRInt64 PROffset64; + + + + + + + +typedef ptrdiff_t PRPtrdiff; +# 456 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" +typedef unsigned long PRUptrdiff; +# 467 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" +typedef PRIntn PRBool; +# 477 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" +typedef PRUint8 PRPackedBool; + + + + + +typedef enum { PR_FAILURE = -1, PR_SUCCESS = 0 } PRStatus; + + + + + + +typedef PRUint16 PRUnichar; +# 509 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" +typedef long PRWord; +typedef unsigned long PRUword; +# 587 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" +} +# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prinrval.h" 1 +# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prinrval.h" +extern "C" { + + + + + +typedef PRUint32 PRIntervalTime; +# 79 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prinrval.h" +extern __attribute__((visibility("default"))) PRIntervalTime PR_IntervalNow(void); +# 97 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prinrval.h" +extern __attribute__((visibility("default"))) PRUint32 PR_TicksPerSecond(void); +# 116 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prinrval.h" +extern __attribute__((visibility("default"))) PRIntervalTime PR_SecondsToInterval(PRUint32 seconds); +extern __attribute__((visibility("default"))) PRIntervalTime PR_MillisecondsToInterval(PRUint32 milli); +extern __attribute__((visibility("default"))) PRIntervalTime PR_MicrosecondsToInterval(PRUint32 micro); +# 137 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prinrval.h" +extern __attribute__((visibility("default"))) PRUint32 PR_IntervalToSeconds(PRIntervalTime ticks); +extern __attribute__((visibility("default"))) PRUint32 PR_IntervalToMilliseconds(PRIntervalTime ticks); +extern __attribute__((visibility("default"))) PRUint32 PR_IntervalToMicroseconds(PRIntervalTime ticks); + +} +# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h" 2 + +extern "C" { + +typedef struct PRThread PRThread; +typedef struct PRThreadStack PRThreadStack; + +typedef enum PRThreadType { + PR_USER_THREAD, + PR_SYSTEM_THREAD +} PRThreadType; + +typedef enum PRThreadScope { + PR_LOCAL_THREAD, + PR_GLOBAL_THREAD, + PR_GLOBAL_BOUND_THREAD +} PRThreadScope; + +typedef enum PRThreadState { + PR_JOINABLE_THREAD, + PR_UNJOINABLE_THREAD +} PRThreadState; + +typedef enum PRThreadPriority +{ + PR_PRIORITY_FIRST = 0, + PR_PRIORITY_LOW = 0, + PR_PRIORITY_NORMAL = 1, + PR_PRIORITY_HIGH = 2, + PR_PRIORITY_URGENT = 3, + PR_PRIORITY_LAST = 3 +} PRThreadPriority; +# 105 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h" +extern __attribute__((visibility("default"))) PRThread* PR_CreateThread(PRThreadType type, + void ( *start)(void *arg), + void *arg, + PRThreadPriority priority, + PRThreadScope scope, + PRThreadState state, + PRUint32 stackSize); +# 126 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h" +extern __attribute__((visibility("default"))) PRStatus PR_JoinThread(PRThread *thread); + + + + + +extern __attribute__((visibility("default"))) PRThread* PR_GetCurrentThread(void); + + + + + + + +extern __attribute__((visibility("default"))) PRThreadPriority PR_GetThreadPriority(const PRThread *thread); +# 152 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h" +extern __attribute__((visibility("default"))) void PR_SetThreadPriority(PRThread *thread, PRThreadPriority priority); + + + + + +extern __attribute__((visibility("default"))) PRStatus PR_SetCurrentThreadName(const char *name); + + + + +extern __attribute__((visibility("default"))) const char * PR_GetThreadName(const PRThread *thread); +# 189 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h" +typedef void ( *PRThreadPrivateDTOR)(void *priv); + +extern __attribute__((visibility("default"))) PRStatus PR_NewThreadPrivateIndex( + PRUintn *newIndex, PRThreadPrivateDTOR destructor); +# 205 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h" +extern __attribute__((visibility("default"))) PRStatus PR_SetThreadPrivate(PRUintn tpdIndex, void *priv); +# 216 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h" +extern __attribute__((visibility("default"))) void* PR_GetThreadPrivate(PRUintn tpdIndex); +# 228 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h" +extern __attribute__((visibility("default"))) PRStatus PR_Interrupt(PRThread *thread); + + + + + +extern __attribute__((visibility("default"))) void PR_ClearInterrupt(void); + + + + +extern __attribute__((visibility("default"))) void PR_BlockInterrupt(void); + + + + +extern __attribute__((visibility("default"))) void PR_UnblockInterrupt(void); +# 253 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h" +extern __attribute__((visibility("default"))) PRStatus PR_Sleep(PRIntervalTime ticks); + + + + +extern __attribute__((visibility("default"))) PRThreadScope PR_GetThreadScope(const PRThread *thread); + + + + +extern __attribute__((visibility("default"))) PRThreadType PR_GetThreadType(const PRThread *thread); + + + + +extern __attribute__((visibility("default"))) PRThreadState PR_GetThreadState(const PRThread *thread); + +} +# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h" 2 +# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MacroForEach.h" 1 +# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h" 2 + + + + + + + +inline nsISupports* +ToSupports(nsISupports* aSupports) +{ + return aSupports; +} + +inline nsISupports* +ToCanonicalSupports(nsISupports* aSupports) +{ + return nullptr; +} +# 174 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h" +class nsCycleCollectingAutoRefCnt +{ +public: + nsCycleCollectingAutoRefCnt() : mRefCntAndFlags(0) {} + + explicit nsCycleCollectingAutoRefCnt(uintptr_t aValue) + : mRefCntAndFlags(aValue << 2) + { + } + + nsCycleCollectingAutoRefCnt(const nsCycleCollectingAutoRefCnt&) = delete; + void operator=(const nsCycleCollectingAutoRefCnt&) = delete; + + __attribute__((always_inline)) inline uintptr_t incr(nsISupports* aOwner) + { + return incr(aOwner, nullptr); + } + + __attribute__((always_inline)) inline uintptr_t incr(void* aOwner, + nsCycleCollectionParticipant* aCp) + { + mRefCntAndFlags += (1 << 2); + mRefCntAndFlags &= ~(1 << 1); + + + if (!IsInPurpleBuffer()) { + mRefCntAndFlags |= (1 << 0); + + do { } while (0); + NS_CycleCollectorSuspect3(aOwner, aCp, this, nullptr); + } + return (mRefCntAndFlags >> 2); + } + + __attribute__((always_inline)) inline void stabilizeForDeletion() + { + + + mRefCntAndFlags = (1 << 2) | (1 << 0); + } + + __attribute__((always_inline)) inline uintptr_t decr(nsISupports* aOwner, + bool* aShouldDelete = nullptr) + { + return decr(aOwner, nullptr, aShouldDelete); + } + + __attribute__((always_inline)) inline uintptr_t decr(void* aOwner, + nsCycleCollectionParticipant* aCp, + bool* aShouldDelete = nullptr) + { + do { } while (0); + if (!IsInPurpleBuffer()) { + mRefCntAndFlags -= (1 << 2); + mRefCntAndFlags |= ((1 << 0) | (1 << 1)); + uintptr_t retval = (mRefCntAndFlags >> 2); + + NS_CycleCollectorSuspect3(aOwner, aCp, this, aShouldDelete); + return retval; + } + mRefCntAndFlags -= (1 << 2); + mRefCntAndFlags |= ((1 << 0) | (1 << 1)); + return (mRefCntAndFlags >> 2); + } + + __attribute__((always_inline)) inline void RemovePurple() + { + do { } while (0); + mRefCntAndFlags &= ~(1 << 1); + } + + __attribute__((always_inline)) inline void RemoveFromPurpleBuffer() + { + do { } while (0); + mRefCntAndFlags &= ~((1 << 1) | (1 << 0)); + } + + __attribute__((always_inline)) inline bool IsPurple() const + { + return !!(mRefCntAndFlags & (1 << 1)); + } + + __attribute__((always_inline)) inline bool IsInPurpleBuffer() const + { + return !!(mRefCntAndFlags & (1 << 0)); + } + + __attribute__((always_inline)) inline nsrefcnt get() const + { + return (mRefCntAndFlags >> 2); + } + + __attribute__((always_inline)) inline operator nsrefcnt() const + { + return get(); + } + +private: + uintptr_t mRefCntAndFlags; +}; + +class nsAutoRefCnt +{ +public: + nsAutoRefCnt() : mValue(0) {} + explicit nsAutoRefCnt(nsrefcnt aValue) : mValue(aValue) {} + + nsAutoRefCnt(const nsAutoRefCnt&) = delete; + void operator=(const nsAutoRefCnt&) = delete; + + + nsrefcnt operator++() { return ++mValue; } + nsrefcnt operator--() { return --mValue; } + + nsrefcnt operator=(nsrefcnt aValue) { return (mValue = aValue); } + operator nsrefcnt() const { return mValue; } + nsrefcnt get() const { return mValue; } + + static const bool isThreadSafe = false; +private: + nsrefcnt operator++(int) = delete; + nsrefcnt operator--(int) = delete; + nsrefcnt mValue; +}; + +namespace mozilla { +class ThreadSafeAutoRefCnt +{ +public: + ThreadSafeAutoRefCnt() : mValue(0) {} + explicit ThreadSafeAutoRefCnt(nsrefcnt aValue) : mValue(aValue) {} + + ThreadSafeAutoRefCnt(const ThreadSafeAutoRefCnt&) = delete; + void operator=(const ThreadSafeAutoRefCnt&) = delete; + + + __attribute__((always_inline)) inline nsrefcnt operator++() + { +# 320 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h" + return mValue.fetch_add(1, std::memory_order_relaxed) + 1; + } + __attribute__((always_inline)) inline nsrefcnt operator--() + { + + + + + nsrefcnt result = mValue.fetch_sub(1, std::memory_order_release) - 1; + if (result == 0) { + + + + + result = mValue.load(std::memory_order_acquire); + } + return result; + } + + __attribute__((always_inline)) inline nsrefcnt operator=(nsrefcnt aValue) + { + + + mValue.store(aValue, std::memory_order_release); + return aValue; + } + __attribute__((always_inline)) inline operator nsrefcnt() const { return get(); } + __attribute__((always_inline)) inline nsrefcnt get() const + { + + + return mValue.load(std::memory_order_acquire); + } + + static const bool isThreadSafe = true; +private: + nsrefcnt operator++(int) = delete; + nsrefcnt operator--(int) = delete; + std::atomic mValue; +}; +} +# 759 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h" +struct QITableEntry +{ + const nsIID* iid; + int32_t offset; +}; + +nsresult +NS_TableDrivenQI(void* aThis, const nsIID& aIID, + void** aInstancePtr, const QITableEntry* aEntries); +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h" 2 +# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h" +template +inline void +ns_if_addref(T aExpr) +{ + if (aExpr) { + aExpr->AddRef(); + } +} +# 121 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h" +template +inline nsresult +CallQueryInterface(T* aSource, DestinationType** aDestination) +{ + + + static_assert(!mozilla::IsSame::value || + mozilla::IsSame::value, + "don't use CallQueryInterface for compile-time-determinable casts"); + + do { } while(0); + do { } while(0); + + return aSource->QueryInterface((DestinationType::template COMTypeInfo::kIID), + reinterpret_cast(aDestination)); +} + +template +inline nsresult +CallQueryInterface(RefPtr& aSourcePtr, DestinationType** aDestPtr) +{ + return CallQueryInterface(aSourcePtr.get(), aDestPtr); +} +# 131 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupports.h" 2 +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionTraversalCallback.h" 2 + +class nsCycleCollectionParticipant; + +class nsCycleCollectionTraversalCallback +{ +public: + + + + + virtual void DescribeRefCountedNode(nsrefcnt aRefcount, + const char* aObjName) = 0; + + virtual void DescribeGCedNode(bool aIsMarked, + const char* aObjName, + uint64_t aCompartmentAddress = 0) = 0; + + virtual void NoteXPCOMChild(nsISupports* aChild) = 0; + virtual void NoteJSChild(const JS::GCCellPtr& aThing) = 0; + virtual void NoteNativeChild(void* aChild, + nsCycleCollectionParticipant* aHelper) = 0; + + + + + + virtual void NoteNextEdgeName(const char* aName) = 0; + + enum + { + + + + + WANT_DEBUG_INFO = (1 << 0), + + + + WANT_ALL_TRACES = (1 << 1) + }; + uint32_t Flags() const { return mFlags; } + bool WantDebugInfo() const { return (mFlags & WANT_DEBUG_INFO) != 0; } + bool WantAllTraces() const { return (mFlags & WANT_ALL_TRACES) != 0; } +protected: + nsCycleCollectionTraversalCallback() : mFlags(0) {} + + uint32_t mFlags; +}; +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionNoteChild.h" 2 + + + +enum +{ + CycleCollectionEdgeNameArrayFlag = 1 +}; + + +void +CycleCollectionNoteEdgeNameImpl(nsCycleCollectionTraversalCallback& aCallback, + const char* aName, + uint32_t aFlags = 0); + + +__attribute__((always_inline)) inline void +CycleCollectionNoteEdgeName(nsCycleCollectionTraversalCallback& aCallback, + const char* aName, + uint32_t aFlags = 0) +{ + if ((__builtin_expect(!!(aCallback.WantDebugInfo()), 0))) { + CycleCollectionNoteEdgeNameImpl(aCallback, aName, aFlags); + } +} +# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionNoteChild.h" +template +nsISupports* +ToSupports(T* aPtr, typename T::cycleCollection* aDummy = 0) +{ + return T::cycleCollection::Upcast(aPtr); +} + + + +template::value> +struct CycleCollectionNoteChildImpl +{ +}; + +template +struct CycleCollectionNoteChildImpl +{ + static void Run(nsCycleCollectionTraversalCallback& aCallback, T* aChild) + { + aCallback.NoteXPCOMChild(ToSupports(aChild)); + } +}; + +template +struct CycleCollectionNoteChildImpl +{ + static void Run(nsCycleCollectionTraversalCallback& aCallback, T* aChild) + { + aCallback.NoteNativeChild(aChild, T::cycleCollection::GetParticipant()); + } +}; + + + + +template +inline void +CycleCollectionNoteChild(nsCycleCollectionTraversalCallback& aCallback, + T* aChild, const char* aName, uint32_t aFlags) +{ + CycleCollectionNoteEdgeName(aCallback, aName, aFlags); + CycleCollectionNoteChildImpl::Run(aCallback, aChild); +} + +template +inline void +CycleCollectionNoteChild(nsCycleCollectionTraversalCallback& aCallback, + T* aChild, const char* aName) +{ + CycleCollectionNoteChild(aCallback, aChild, aName, 0); +} +# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAlgorithm.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAlgorithm.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCharTraits.h" 1 +# 86 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCharTraits.h" +template +struct nsCharTraits +{ +}; + +template <> +struct nsCharTraits +{ + typedef char16_t char_type; + typedef uint16_t unsigned_char_type; + typedef char incompatible_char_type; + + static char_type* const sEmptyBuffer; + + static void + assign(char_type& aLhs, char_type aRhs) + { + aLhs = aRhs; + } + + + + typedef int int_type; + + static char_type + to_char_type(int_type aChar) + { + return char_type(aChar); + } + + static int_type + to_int_type(char_type aChar) + { + return int_type(static_cast(aChar)); + } + + static bool + eq_int_type(int_type aLhs, int_type aRhs) + { + return aLhs == aRhs; + } + + + + + static bool + eq(char_type aLhs, char_type aRhs) + { + return aLhs == aRhs; + } + + static bool + lt(char_type aLhs, char_type aRhs) + { + return aLhs < aRhs; + } + + + + + static char_type* + move(char_type* aStr1, const char_type* aStr2, size_t aN) + { + return static_cast(memmove(aStr1, aStr2, + aN * sizeof(char_type))); + } + + static char_type* + copy(char_type* aStr1, const char_type* aStr2, size_t aN) + { + return static_cast(memcpy(aStr1, aStr2, + aN * sizeof(char_type))); + } + + static char_type* + copyASCII(char_type* aStr1, const char* aStr2, size_t aN) + { + for (char_type* s = aStr1; aN--; ++s, ++aStr2) { + do { } while(0); + *s = static_cast(*aStr2); + } + return aStr1; + } + + static char_type* + assign(char_type* aStr, size_t aN, char_type aChar) + { + char_type* result = aStr; + while (aN--) { + assign(*aStr++, aChar); + } + return result; + } + + static int + compare(const char_type* aStr1, const char_type* aStr2, size_t aN) + { + for (; aN--; ++aStr1, ++aStr2) { + if (!eq(*aStr1, *aStr2)) { + return to_int_type(*aStr1) - to_int_type(*aStr2); + } + } + + return 0; + } + + static int + compareASCII(const char_type* aStr1, const char* aStr2, size_t aN) + { + for (; aN--; ++aStr1, ++aStr2) { + do { } while(0); + if (!eq_int_type(to_int_type(*aStr1), + to_int_type(static_cast(*aStr2)))) { + return to_int_type(*aStr1) - + to_int_type(static_cast(*aStr2)); + } + } + + return 0; + } + + + + + static int + compareASCIINullTerminated(const char_type* aStr1, size_t aN, + const char* aStr2) + { + for (; aN--; ++aStr1, ++aStr2) { + if (!*aStr2) { + return 1; + } + do { } while(0); + if (!eq_int_type(to_int_type(*aStr1), + to_int_type(static_cast(*aStr2)))) { + return to_int_type(*aStr1) - + to_int_type(static_cast(*aStr2)); + } + } + + if (*aStr2) { + return -1; + } + + return 0; + } + + + + + + static char_type + ASCIIToLower(char_type aChar) + { + if (aChar >= 'A' && aChar <= 'Z') { + return char_type(aChar + ('a' - 'A')); + } + + return aChar; + } + + static int + compareLowerCaseToASCII(const char_type* aStr1, const char* aStr2, size_t aN) + { + for (; aN--; ++aStr1, ++aStr2) { + do { } while(0); + do { } while(0); + + char_type lower_s1 = ASCIIToLower(*aStr1); + if (lower_s1 != static_cast(*aStr2)) { + return to_int_type(lower_s1) - + to_int_type(static_cast(*aStr2)); + } + } + + return 0; + } + + + + + static int + compareLowerCaseToASCIINullTerminated(const char_type* aStr1, + size_t aN, const char* aStr2) + { + for (; aN--; ++aStr1, ++aStr2) { + if (!*aStr2) { + return 1; + } + do { } while(0); + do { } while(0); + + char_type lower_s1 = ASCIIToLower(*aStr1); + if (lower_s1 != static_cast(*aStr2)) { + return to_int_type(lower_s1) - + to_int_type(static_cast(*aStr2)); + } + } + + if (*aStr2) { + return -1; + } + + return 0; + } + + static size_t + length(const char_type* aStr) + { + size_t result = 0; + while (!eq(*aStr++, char_type(0))) { + ++result; + } + return result; + } + + static const char_type* + find(const char_type* aStr, size_t aN, char_type aChar) + { + while (aN--) { + if (eq(*aStr, aChar)) { + return aStr; + } + ++aStr; + } + + return 0; + } +}; + +template <> +struct nsCharTraits +{ + typedef char char_type; + typedef unsigned char unsigned_char_type; + typedef char16_t incompatible_char_type; + + static char_type* const sEmptyBuffer; + + static void + assign(char_type& aLhs, char_type aRhs) + { + aLhs = aRhs; + } + + + + + typedef int int_type; + + static char_type + to_char_type(int_type aChar) + { + return char_type(aChar); + } + + static int_type + to_int_type(char_type aChar) + { + return int_type(static_cast(aChar)); + } + + static bool + eq_int_type(int_type aLhs, int_type aRhs) + { + return aLhs == aRhs; + } + + + + + static bool eq(char_type aLhs, char_type aRhs) + { + return aLhs == aRhs; + } + + static bool + lt(char_type aLhs, char_type aRhs) + { + return aLhs < aRhs; + } + + + + + static char_type* + move(char_type* aStr1, const char_type* aStr2, size_t aN) + { + return static_cast(memmove(aStr1, aStr2, + aN * sizeof(char_type))); + } + + static char_type* + copy(char_type* aStr1, const char_type* aStr2, size_t aN) + { + return static_cast(memcpy(aStr1, aStr2, + aN * sizeof(char_type))); + } + + static char_type* + copyASCII(char_type* aStr1, const char* aStr2, size_t aN) + { + return copy(aStr1, aStr2, aN); + } + + static char_type* + assign(char_type* aStr, size_t aN, char_type aChar) + { + return static_cast(memset(aStr, to_int_type(aChar), aN)); + } + + static int + compare(const char_type* aStr1, const char_type* aStr2, size_t aN) + { + return memcmp(aStr1, aStr2, aN); + } + + static int + compareASCII(const char_type* aStr1, const char* aStr2, size_t aN) + { + + + + + + return compare(aStr1, aStr2, aN); + } + + + + + static int + compareASCIINullTerminated(const char_type* aStr1, size_t aN, + const char* aStr2) + { + + + for (; aN--; ++aStr1, ++aStr2) { + if (!*aStr2) { + return 1; + } + do { } while(0); + if (*aStr1 != *aStr2) { + return to_int_type(*aStr1) - to_int_type(*aStr2); + } + } + + if (*aStr2) { + return -1; + } + + return 0; + } + + + + + static char_type + ASCIIToLower(char_type aChar) + { + if (aChar >= 'A' && aChar <= 'Z') { + return char_type(aChar + ('a' - 'A')); + } + + return aChar; + } + + static int + compareLowerCaseToASCII(const char_type* aStr1, const char* aStr2, size_t aN) + { + for (; aN--; ++aStr1, ++aStr2) { + do { } while(0); + do { } while(0); + + char_type lower_s1 = ASCIIToLower(*aStr1); + if (lower_s1 != *aStr2) { + return to_int_type(lower_s1) - to_int_type(*aStr2); + } + } + return 0; + } + + + + + static int + compareLowerCaseToASCIINullTerminated(const char_type* aStr1, size_t aN, + const char* aStr2) + { + for (; aN--; ++aStr1, ++aStr2) { + if (!*aStr2) { + return 1; + } + do { } while(0); + do { } while(0); + + char_type lower_s1 = ASCIIToLower(*aStr1); + if (lower_s1 != *aStr2) { + return to_int_type(lower_s1) - to_int_type(*aStr2); + } + } + + if (*aStr2) { + return -1; + } + + return 0; + } + + static size_t + length(const char_type* aStr) + { + return strlen(aStr); + } + + static const char_type* + find(const char_type* aStr, size_t aN, char_type aChar) + { + return reinterpret_cast(memchr(aStr, to_int_type(aChar), + aN)); + } +}; + +template +struct nsCharSourceTraits +{ + typedef typename InputIterator::difference_type difference_type; + + static uint32_t + readable_distance(const InputIterator& aFirst, const InputIterator& aLast) + { + + return uint32_t(aLast.get() - aFirst.get()); + } + + static const typename InputIterator::value_type* + read(const InputIterator& aIter) + { + return aIter.get(); + } + + static void + advance(InputIterator& aStr, difference_type aN) + { + aStr.advance(aN); + } +}; + +template +struct nsCharSourceTraits +{ + typedef ptrdiff_t difference_type; + + static uint32_t + readable_distance(CharT* aStr) + { + return uint32_t(nsCharTraits::length(aStr)); + + } + + static uint32_t + readable_distance(CharT* aFirst, CharT* aLast) + { + return uint32_t(aLast - aFirst); + } + + static const CharT* + read(CharT* aStr) + { + return aStr; + } + + static void + advance(CharT*& aStr, difference_type aN) + { + aStr += aN; + } +}; + +template +struct nsCharSinkTraits +{ + static void + write(OutputIterator& aIter, const typename OutputIterator::value_type* aStr, + uint32_t aN) + { + aIter.write(aStr, aN); + } +}; + +template +struct nsCharSinkTraits +{ + static void + write(CharT*& aIter, const CharT* aStr, uint32_t aN) + { + nsCharTraits::move(aIter, aStr, aN); + aIter += aN; + } +}; +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAlgorithm.h" 2 + +template +inline T +NS_ROUNDUP(const T& aA, const T& aB) +{ + return ((aA + (aB - 1)) / aB) * aB; +} + + + + +template +inline const T& +XPCOM_MIN(const T& aA, const T& aB) +{ + return aB < aA ? aB : aA; +} + + +template +inline const T& +XPCOM_MAX(const T& aA, const T& aB) +{ + return aA > aB ? aA : aB; +} + +namespace mozilla { + +template +inline const T& +clamped(const T& aA, const T& aMin, const T& aMax) +{ + do { } while (0); + + return XPCOM_MIN(XPCOM_MAX(aA, aMin), aMax); +} + +} + +template +inline uint32_t +NS_COUNT(InputIterator& aFirst, const InputIterator& aLast, const T& aValue) +{ + uint32_t result = 0; + for (; aFirst != aLast; ++aFirst) + if (*aFirst == aValue) { + ++result; + } + return result; +} + +template +inline OutputIterator& +copy_string(const InputIterator& aFirst, const InputIterator& aLast, + OutputIterator& aResult) +{ + typedef nsCharSourceTraits source_traits; + typedef nsCharSinkTraits sink_traits; + + sink_traits::write(aResult, source_traits::read(aFirst), + source_traits::readable_distance(aFirst, aLast)); + return aResult; +} +# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2 + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsQuickSort.h" 1 +# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsQuickSort.h" +extern "C" { +# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsQuickSort.h" +void NS_QuickSort(void*, unsigned int, unsigned int, + int (*)(const void*, const void*, void*), + void*); + + +} +# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2 + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegionFwd.h" 1 +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegionFwd.h" +namespace mozilla { +namespace gfx { + +struct UnknownUnits; + +template +class IntRegionTyped; + +typedef IntRegionTyped IntRegion; + +} +} + +typedef mozilla::gfx::IntRegion nsIntRegion; +# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 1 3 +# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + + + + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/typeinfo" 1 3 +# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/typeinfo" 3 + + + + + + +#pragma GCC visibility push(default) + +extern "C++" { + +namespace __cxxabiv1 +{ + class __class_type_info; +} +# 80 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/typeinfo" 3 +namespace std +{ + + + + + + + class type_info + { + public: + + + + + virtual ~type_info(); + + + + const char* name() const noexcept + { return __name[0] == '*' ? __name + 1 : __name; } +# 115 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/typeinfo" 3 + bool before(const type_info& __arg) const noexcept + { return (__name[0] == '*' && __arg.__name[0] == '*') + ? __name < __arg.__name + : __builtin_strcmp (__name, __arg.__name) < 0; } + + bool operator==(const type_info& __arg) const noexcept + { + return ((__name == __arg.__name) + || (__name[0] != '*' && + __builtin_strcmp (__name, __arg.__name) == 0)); + } +# 136 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/typeinfo" 3 + bool operator!=(const type_info& __arg) const noexcept + { return !operator==(__arg); } + + + size_t hash_code() const noexcept + { + + return _Hash_bytes(name(), __builtin_strlen(name()), + static_cast(0xc70f6907UL)); + + + + } + + + + virtual bool __is_pointer_p() const; + + + virtual bool __is_function_p() const; + + + + + + + + virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj, + unsigned __outer) const; + + + virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target, + void **__obj_ptr) const; + + protected: + const char *__name; + + explicit type_info(const char *__n): __name(__n) { } + + private: + + type_info& operator=(const type_info&); + type_info(const type_info&); + }; + + + + + + + + class bad_cast : public exception + { + public: + bad_cast() noexcept { } + + + + virtual ~bad_cast() noexcept; + + + virtual const char* what() const noexcept; + }; + + + + + + class bad_typeid : public exception + { + public: + bad_typeid () noexcept { } + + + + virtual ~bad_typeid() noexcept; + + + virtual const char* what() const noexcept; + }; +} + +} + +#pragma GCC visibility pop +# 54 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 2 3 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/tuple" 1 3 +# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/tuple" 3 + + + + + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uses_allocator.h" 1 3 +# 35 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uses_allocator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + struct __erased_type { }; + + template + using __is_erased_or_convertible + = __or_, is_convertible<_Alloc, _Tp>>; + + + struct allocator_arg_t { explicit allocator_arg_t() = default; }; + + constexpr allocator_arg_t allocator_arg = allocator_arg_t(); + + template> + struct __uses_allocator_helper + : false_type { }; + + template + struct __uses_allocator_helper<_Tp, _Alloc, + __void_t> + : __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type + { }; + + + template + struct uses_allocator + : __uses_allocator_helper<_Tp, _Alloc>::type + { }; + + struct __uses_alloc_base { }; + + struct __uses_alloc0 : __uses_alloc_base + { + struct _Sink { void operator=(const void*) { } } _M_a; + }; + + template + struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; }; + + template + struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; }; + + template + struct __uses_alloc; + + template + struct __uses_alloc + : conditional< + is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value, + __uses_alloc1<_Alloc>, + __uses_alloc2<_Alloc>>::type + { + static_assert(__or_< + is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>, + is_constructible<_Tp, _Args..., _Alloc>>::value, "construction with" + " an allocator must be possible if uses_allocator is true"); + }; + + template + struct __uses_alloc + : __uses_alloc0 { }; + + template + using __uses_alloc_t = + __uses_alloc::value, _Tp, _Alloc, _Args...>; + + template + inline __uses_alloc_t<_Tp, _Alloc, _Args...> + __use_alloc(const _Alloc& __a) + { + __uses_alloc_t<_Tp, _Alloc, _Args...> __ret; + __ret._M_a = std::__addressof(__a); + return __ret; + } + + +} +# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/tuple" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + struct _Head_base; + + template + struct _Head_base<_Idx, _Head, true> + : public _Head + { + constexpr _Head_base() + : _Head() { } + + constexpr _Head_base(const _Head& __h) + : _Head(__h) { } + + constexpr _Head_base(const _Head_base&) = default; + constexpr _Head_base(_Head_base&&) = default; + + template + constexpr _Head_base(_UHead&& __h) + : _Head(std::forward<_UHead>(__h)) { } + + _Head_base(allocator_arg_t, __uses_alloc0) + : _Head() { } + + template + _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) + : _Head(allocator_arg, *__a._M_a) { } + + template + _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) + : _Head(*__a._M_a) { } + + template + _Head_base(__uses_alloc0, _UHead&& __uhead) + : _Head(std::forward<_UHead>(__uhead)) { } + + template + _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) + : _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { } + + template + _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) + : _Head(std::forward<_UHead>(__uhead), *__a._M_a) { } + + static constexpr _Head& + _M_head(_Head_base& __b) noexcept { return __b; } + + static constexpr const _Head& + _M_head(const _Head_base& __b) noexcept { return __b; } + }; + + template + struct _Head_base<_Idx, _Head, false> + { + constexpr _Head_base() + : _M_head_impl() { } + + constexpr _Head_base(const _Head& __h) + : _M_head_impl(__h) { } + + constexpr _Head_base(const _Head_base&) = default; + constexpr _Head_base(_Head_base&&) = default; + + template + constexpr _Head_base(_UHead&& __h) + : _M_head_impl(std::forward<_UHead>(__h)) { } + + _Head_base(allocator_arg_t, __uses_alloc0) + : _M_head_impl() { } + + template + _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) + : _M_head_impl(allocator_arg, *__a._M_a) { } + + template + _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) + : _M_head_impl(*__a._M_a) { } + + template + _Head_base(__uses_alloc0, _UHead&& __uhead) + : _M_head_impl(std::forward<_UHead>(__uhead)) { } + + template + _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) + : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) + { } + + template + _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) + : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } + + static constexpr _Head& + _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } + + static constexpr const _Head& + _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } + + _Head _M_head_impl; + }; +# 158 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/tuple" 3 + template + struct _Tuple_impl; + + template + struct __is_empty_non_tuple : is_empty<_Tp> { }; + + + template + struct __is_empty_non_tuple> : false_type { }; + + + template + using __empty_not_final + = typename conditional<__is_final(_Tp), false_type, + __is_empty_non_tuple<_Tp>>::type; + + + + + + + template + struct _Tuple_impl<_Idx, _Head, _Tail...> + : public _Tuple_impl<_Idx + 1, _Tail...>, + private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> + { + template friend class _Tuple_impl; + + typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited; + typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base; + + static constexpr _Head& + _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } + + static constexpr const _Head& + _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } + + static constexpr _Inherited& + _M_tail(_Tuple_impl& __t) noexcept { return __t; } + + static constexpr const _Inherited& + _M_tail(const _Tuple_impl& __t) noexcept { return __t; } + + constexpr _Tuple_impl() + : _Inherited(), _Base() { } + + explicit + constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail) + : _Inherited(__tail...), _Base(__head) { } + + template::type> + explicit + constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail) + : _Inherited(std::forward<_UTail>(__tail)...), + _Base(std::forward<_UHead>(__head)) { } + + constexpr _Tuple_impl(const _Tuple_impl&) = default; + + constexpr + _Tuple_impl(_Tuple_impl&& __in) + noexcept(__and_, + is_nothrow_move_constructible<_Inherited>>::value) + : _Inherited(std::move(_M_tail(__in))), + _Base(std::forward<_Head>(_M_head(__in))) { } + + template + constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in) + : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)), + _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { } + + template + constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) + : _Inherited(std::move + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), + _Base(std::forward<_UHead> + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { } + + template + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) + : _Inherited(__tag, __a), + _Base(__tag, __use_alloc<_Head>(__a)) { } + + template + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Head& __head, const _Tail&... __tail) + : _Inherited(__tag, __a, __tail...), + _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { } + + template::type> + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _UHead&& __head, _UTail&&... __tail) + : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...), + _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), + std::forward<_UHead>(__head)) { } + + template + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Tuple_impl& __in) + : _Inherited(__tag, __a, _M_tail(__in)), + _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { } + + template + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _Tuple_impl&& __in) + : _Inherited(__tag, __a, std::move(_M_tail(__in))), + _Base(__use_alloc<_Head, _Alloc, _Head>(__a), + std::forward<_Head>(_M_head(__in))) { } + + template + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Tuple_impl<_Idx, _UElements...>& __in) + : _Inherited(__tag, __a, + _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)), + _Base(__use_alloc<_Head, _Alloc, _Head>(__a), + _Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { } + + template + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _Tuple_impl<_Idx, _UHead, _UTails...>&& __in) + : _Inherited(__tag, __a, std::move + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), + _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), + std::forward<_UHead> + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { } + + _Tuple_impl& + operator=(const _Tuple_impl& __in) + { + _M_head(*this) = _M_head(__in); + _M_tail(*this) = _M_tail(__in); + return *this; + } + + _Tuple_impl& + operator=(_Tuple_impl&& __in) + noexcept(__and_, + is_nothrow_move_assignable<_Inherited>>::value) + { + _M_head(*this) = std::forward<_Head>(_M_head(__in)); + _M_tail(*this) = std::move(_M_tail(__in)); + return *this; + } + + template + _Tuple_impl& + operator=(const _Tuple_impl<_Idx, _UElements...>& __in) + { + _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in); + _M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_M_tail(__in); + return *this; + } + + template + _Tuple_impl& + operator=(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) + { + _M_head(*this) = std::forward<_UHead> + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)); + _M_tail(*this) = std::move + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)); + return *this; + } + + protected: + void + _M_swap(_Tuple_impl& __in) + noexcept(__is_nothrow_swappable<_Head>::value + && noexcept(_M_tail(__in)._M_swap(_M_tail(__in)))) + { + using std::swap; + swap(_M_head(*this), _M_head(__in)); + _Inherited::_M_swap(_M_tail(__in)); + } + }; + + + template + struct _Tuple_impl<_Idx, _Head> + : private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> + { + template friend class _Tuple_impl; + + typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base; + + static constexpr _Head& + _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } + + static constexpr const _Head& + _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } + + constexpr _Tuple_impl() + : _Base() { } + + explicit + constexpr _Tuple_impl(const _Head& __head) + : _Base(__head) { } + + template + explicit + constexpr _Tuple_impl(_UHead&& __head) + : _Base(std::forward<_UHead>(__head)) { } + + constexpr _Tuple_impl(const _Tuple_impl&) = default; + + constexpr + _Tuple_impl(_Tuple_impl&& __in) + noexcept(is_nothrow_move_constructible<_Head>::value) + : _Base(std::forward<_Head>(_M_head(__in))) { } + + template + constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in) + : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { } + + template + constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in) + : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) + { } + + template + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) + : _Base(__tag, __use_alloc<_Head>(__a)) { } + + template + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Head& __head) + : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { } + + template + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _UHead&& __head) + : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), + std::forward<_UHead>(__head)) { } + + template + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Tuple_impl& __in) + : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { } + + template + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _Tuple_impl&& __in) + : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), + std::forward<_Head>(_M_head(__in))) { } + + template + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Tuple_impl<_Idx, _UHead>& __in) + : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), + _Tuple_impl<_Idx, _UHead>::_M_head(__in)) { } + + template + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _Tuple_impl<_Idx, _UHead>&& __in) + : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), + std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) + { } + + _Tuple_impl& + operator=(const _Tuple_impl& __in) + { + _M_head(*this) = _M_head(__in); + return *this; + } + + _Tuple_impl& + operator=(_Tuple_impl&& __in) + noexcept(is_nothrow_move_assignable<_Head>::value) + { + _M_head(*this) = std::forward<_Head>(_M_head(__in)); + return *this; + } + + template + _Tuple_impl& + operator=(const _Tuple_impl<_Idx, _UHead>& __in) + { + _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in); + return *this; + } + + template + _Tuple_impl& + operator=(_Tuple_impl<_Idx, _UHead>&& __in) + { + _M_head(*this) + = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)); + return *this; + } + + protected: + void + _M_swap(_Tuple_impl& __in) + noexcept(__is_nothrow_swappable<_Head>::value) + { + using std::swap; + swap(_M_head(*this), _M_head(__in)); + } + }; + + template + class tuple; + + + + template + struct _TC + { + template + static constexpr bool _ConstructibleTuple() + { + return __and_...>::value; + } + + template + static constexpr bool _ImplicitlyConvertibleTuple() + { + return __and_...>::value; + } + + template + static constexpr bool _MoveConstructibleTuple() + { + return __and_...>::value; + } + + template + static constexpr bool _ImplicitlyMoveConvertibleTuple() + { + return __and_...>::value; + } + + template + static constexpr bool _NonNestedTuple() + { + return __and_<__not_, + typename remove_cv< + typename remove_reference<_SrcTuple>::type + >::type>>, + __not_>, + __not_> + >::value; + } + template + static constexpr bool _NotSameTuple() + { + return __not_, + typename remove_const< + typename remove_reference<_UElements...>::type + >::type>>::value; + } + }; + + template + struct _TC + { + template + static constexpr bool _ConstructibleTuple() + { + return false; + } + + template + static constexpr bool _ImplicitlyConvertibleTuple() + { + return false; + } + + template + static constexpr bool _MoveConstructibleTuple() + { + return false; + } + + template + static constexpr bool _ImplicitlyMoveConvertibleTuple() + { + return false; + } + + template + static constexpr bool _NonNestedTuple() + { + return true; + } + template + static constexpr bool _NotSameTuple() + { + return true; + } + }; + + + template + class tuple : public _Tuple_impl<0, _Elements...> + { + typedef _Tuple_impl<0, _Elements...> _Inherited; + + + + template + struct _TC2 + { + static constexpr bool _DefaultConstructibleTuple() + { + return __and_...>::value; + } + static constexpr bool _ImplicitlyDefaultConstructibleTuple() + { + return __and_<__is_implicitly_default_constructible<_Elements>...> + ::value; + } + }; + + public: + template:: + _ImplicitlyDefaultConstructibleTuple(), + bool>::type = true> + constexpr tuple() + : _Inherited() { } + + template:: + _DefaultConstructibleTuple() + && + !_TC2<_Dummy>:: + _ImplicitlyDefaultConstructibleTuple(), + bool>::type = false> + explicit constexpr tuple() + : _Inherited() { } + + + + template using _TCC = + _TC::value, + _Elements...>; + + template::template + _ConstructibleTuple<_Elements...>() + && _TCC<_Dummy>::template + _ImplicitlyConvertibleTuple<_Elements...>() + && (sizeof...(_Elements) >= 1), + bool>::type=true> + constexpr tuple(const _Elements&... __elements) + : _Inherited(__elements...) { } + + template::template + _ConstructibleTuple<_Elements...>() + && !_TCC<_Dummy>::template + _ImplicitlyConvertibleTuple<_Elements...>() + && (sizeof...(_Elements) >= 1), + bool>::type=false> + explicit constexpr tuple(const _Elements&... __elements) + : _Inherited(__elements...) { } + + + + template using _TMC = + _TC<(sizeof...(_Elements) == sizeof...(_UElements)), + _Elements...>; + + template::template + _NotSameTuple<_UElements...>() + && _TMC<_UElements...>::template + _MoveConstructibleTuple<_UElements...>() + && _TMC<_UElements...>::template + _ImplicitlyMoveConvertibleTuple<_UElements...>() + && (sizeof...(_Elements) >= 1), + bool>::type=true> + constexpr tuple(_UElements&&... __elements) + : _Inherited(std::forward<_UElements>(__elements)...) { } + + template::template + _NotSameTuple<_UElements...>() + && _TMC<_UElements...>::template + _MoveConstructibleTuple<_UElements...>() + && !_TMC<_UElements...>::template + _ImplicitlyMoveConvertibleTuple<_UElements...>() + && (sizeof...(_Elements) >= 1), + bool>::type=false> + explicit constexpr tuple(_UElements&&... __elements) + : _Inherited(std::forward<_UElements>(__elements)...) { } + + constexpr tuple(const tuple&) = default; + + constexpr tuple(tuple&&) = default; + + + + template using _TNTC = + _TC::value && sizeof...(_Elements) == 1, + _Elements...>; + + template::template + _ConstructibleTuple<_UElements...>() + && _TMC<_UElements...>::template + _ImplicitlyConvertibleTuple<_UElements...>() + && _TNTC<_Dummy>::template + _NonNestedTuple&>(), + bool>::type=true> + constexpr tuple(const tuple<_UElements...>& __in) + : _Inherited(static_cast&>(__in)) + { } + + template::template + _ConstructibleTuple<_UElements...>() + && !_TMC<_UElements...>::template + _ImplicitlyConvertibleTuple<_UElements...>() + && _TNTC<_Dummy>::template + _NonNestedTuple&>(), + bool>::type=false> + explicit constexpr tuple(const tuple<_UElements...>& __in) + : _Inherited(static_cast&>(__in)) + { } + + template::template + _MoveConstructibleTuple<_UElements...>() + && _TMC<_UElements...>::template + _ImplicitlyMoveConvertibleTuple<_UElements...>() + && _TNTC<_Dummy>::template + _NonNestedTuple&&>(), + bool>::type=true> + constexpr tuple(tuple<_UElements...>&& __in) + : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } + + template::template + _MoveConstructibleTuple<_UElements...>() + && !_TMC<_UElements...>::template + _ImplicitlyMoveConvertibleTuple<_UElements...>() + && _TNTC<_Dummy>::template + _NonNestedTuple&&>(), + bool>::type=false> + explicit constexpr tuple(tuple<_UElements...>&& __in) + : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } + + + + template + tuple(allocator_arg_t __tag, const _Alloc& __a) + : _Inherited(__tag, __a) { } + + template::template + _ConstructibleTuple<_Elements...>() + && _TCC<_Dummy>::template + _ImplicitlyConvertibleTuple<_Elements...>(), + bool>::type=true> + tuple(allocator_arg_t __tag, const _Alloc& __a, + const _Elements&... __elements) + : _Inherited(__tag, __a, __elements...) { } + + template::template + _ConstructibleTuple<_Elements...>() + && !_TCC<_Dummy>::template + _ImplicitlyConvertibleTuple<_Elements...>(), + bool>::type=false> + explicit tuple(allocator_arg_t __tag, const _Alloc& __a, + const _Elements&... __elements) + : _Inherited(__tag, __a, __elements...) { } + + template::template + _MoveConstructibleTuple<_UElements...>() + && _TMC<_UElements...>::template + _ImplicitlyMoveConvertibleTuple<_UElements...>(), + bool>::type=true> + tuple(allocator_arg_t __tag, const _Alloc& __a, + _UElements&&... __elements) + : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) + { } + + template::template + _MoveConstructibleTuple<_UElements...>() + && !_TMC<_UElements...>::template + _ImplicitlyMoveConvertibleTuple<_UElements...>(), + bool>::type=false> + explicit tuple(allocator_arg_t __tag, const _Alloc& __a, + _UElements&&... __elements) + : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) + { } + + template + tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) + : _Inherited(__tag, __a, static_cast(__in)) { } + + template + tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) + : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } + + template::template + _ConstructibleTuple<_UElements...>() + && _TMC<_UElements...>::template + _ImplicitlyConvertibleTuple<_UElements...>(), + bool>::type=true> + tuple(allocator_arg_t __tag, const _Alloc& __a, + const tuple<_UElements...>& __in) + : _Inherited(__tag, __a, + static_cast&>(__in)) + { } + + template::template + _ConstructibleTuple<_UElements...>() + && !_TMC<_UElements...>::template + _ImplicitlyConvertibleTuple<_UElements...>(), + bool>::type=false> + explicit tuple(allocator_arg_t __tag, const _Alloc& __a, + const tuple<_UElements...>& __in) + : _Inherited(__tag, __a, + static_cast&>(__in)) + { } + + template::template + _MoveConstructibleTuple<_UElements...>() + && _TMC<_UElements...>::template + _ImplicitlyMoveConvertibleTuple<_UElements...>(), + bool>::type=true> + tuple(allocator_arg_t __tag, const _Alloc& __a, + tuple<_UElements...>&& __in) + : _Inherited(__tag, __a, + static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) + { } + + template::template + _MoveConstructibleTuple<_UElements...>() + && !_TMC<_UElements...>::template + _ImplicitlyMoveConvertibleTuple<_UElements...>(), + bool>::type=false> + explicit tuple(allocator_arg_t __tag, const _Alloc& __a, + tuple<_UElements...>&& __in) + : _Inherited(__tag, __a, + static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) + { } + + tuple& + operator=(const tuple& __in) + { + static_cast<_Inherited&>(*this) = __in; + return *this; + } + + tuple& + operator=(tuple&& __in) + noexcept(is_nothrow_move_assignable<_Inherited>::value) + { + static_cast<_Inherited&>(*this) = std::move(__in); + return *this; + } + + template::type> + tuple& + operator=(const tuple<_UElements...>& __in) + { + static_cast<_Inherited&>(*this) = __in; + return *this; + } + + template::type> + tuple& + operator=(tuple<_UElements...>&& __in) + { + static_cast<_Inherited&>(*this) = std::move(__in); + return *this; + } + + void + swap(tuple& __in) + noexcept(noexcept(__in._M_swap(__in))) + { _Inherited::_M_swap(__in); } + }; + + + template<> + class tuple<> + { + public: + void swap(tuple&) noexcept { } + }; + + + + template + class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2> + { + typedef _Tuple_impl<0, _T1, _T2> _Inherited; + + public: + template , + __is_implicitly_default_constructible<_U2>> + ::value, bool>::type = true> + + constexpr tuple() + : _Inherited() { } + + template , + is_default_constructible<_U2>, + __not_< + __and_<__is_implicitly_default_constructible<_U1>, + __is_implicitly_default_constructible<_U2>>>> + ::value, bool>::type = false> + + explicit constexpr tuple() + : _Inherited() { } + + + + template using _TCC = + _TC::value, _T1, _T2>; + + template::template + _ConstructibleTuple<_T1, _T2>() + && _TCC<_Dummy>::template + _ImplicitlyConvertibleTuple<_T1, _T2>(), + bool>::type = true> + constexpr tuple(const _T1& __a1, const _T2& __a2) + : _Inherited(__a1, __a2) { } + + template::template + _ConstructibleTuple<_T1, _T2>() + && !_TCC<_Dummy>::template + _ImplicitlyConvertibleTuple<_T1, _T2>(), + bool>::type = false> + explicit constexpr tuple(const _T1& __a1, const _T2& __a2) + : _Inherited(__a1, __a2) { } + + + + using _TMC = _TC; + + template() + && _TMC::template + _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), + bool>::type = true> + constexpr tuple(_U1&& __a1, _U2&& __a2) + : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } + + template() + && !_TMC::template + _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), + bool>::type = false> + explicit constexpr tuple(_U1&& __a1, _U2&& __a2) + : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } + + constexpr tuple(const tuple&) = default; + + constexpr tuple(tuple&&) = default; + + template() + && _TMC::template + _ImplicitlyConvertibleTuple<_U1, _U2>(), + bool>::type = true> + constexpr tuple(const tuple<_U1, _U2>& __in) + : _Inherited(static_cast&>(__in)) { } + + template() + && !_TMC::template + _ImplicitlyConvertibleTuple<_U1, _U2>(), + bool>::type = false> + explicit constexpr tuple(const tuple<_U1, _U2>& __in) + : _Inherited(static_cast&>(__in)) { } + + template() + && _TMC::template + _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), + bool>::type = true> + constexpr tuple(tuple<_U1, _U2>&& __in) + : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } + + template() + && !_TMC::template + _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), + bool>::type = false> + explicit constexpr tuple(tuple<_U1, _U2>&& __in) + : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } + + template() + && _TMC::template + _ImplicitlyConvertibleTuple<_U1, _U2>(), + bool>::type = true> + constexpr tuple(const pair<_U1, _U2>& __in) + : _Inherited(__in.first, __in.second) { } + + template() + && !_TMC::template + _ImplicitlyConvertibleTuple<_U1, _U2>(), + bool>::type = false> + explicit constexpr tuple(const pair<_U1, _U2>& __in) + : _Inherited(__in.first, __in.second) { } + + template() + && _TMC::template + _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), + bool>::type = true> + constexpr tuple(pair<_U1, _U2>&& __in) + : _Inherited(std::forward<_U1>(__in.first), + std::forward<_U2>(__in.second)) { } + + template() + && !_TMC::template + _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), + bool>::type = false> + explicit constexpr tuple(pair<_U1, _U2>&& __in) + : _Inherited(std::forward<_U1>(__in.first), + std::forward<_U2>(__in.second)) { } + + + + template + tuple(allocator_arg_t __tag, const _Alloc& __a) + : _Inherited(__tag, __a) { } + + template::template + _ConstructibleTuple<_T1, _T2>() + && _TCC<_Dummy>::template + _ImplicitlyConvertibleTuple<_T1, _T2>(), + bool>::type=true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const _T1& __a1, const _T2& __a2) + : _Inherited(__tag, __a, __a1, __a2) { } + + template::template + _ConstructibleTuple<_T1, _T2>() + && !_TCC<_Dummy>::template + _ImplicitlyConvertibleTuple<_T1, _T2>(), + bool>::type=false> + + explicit tuple(allocator_arg_t __tag, const _Alloc& __a, + const _T1& __a1, const _T2& __a2) + : _Inherited(__tag, __a, __a1, __a2) { } + + template() + && _TMC::template + _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), + bool>::type = true> + tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2) + : _Inherited(__tag, __a, std::forward<_U1>(__a1), + std::forward<_U2>(__a2)) { } + + template() + && !_TMC::template + _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), + bool>::type = false> + explicit tuple(allocator_arg_t __tag, const _Alloc& __a, + _U1&& __a1, _U2&& __a2) + : _Inherited(__tag, __a, std::forward<_U1>(__a1), + std::forward<_U2>(__a2)) { } + + template + tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) + : _Inherited(__tag, __a, static_cast(__in)) { } + + template + tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) + : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } + + template() + && _TMC::template + _ImplicitlyConvertibleTuple<_U1, _U2>(), + bool>::type = true> + tuple(allocator_arg_t __tag, const _Alloc& __a, + const tuple<_U1, _U2>& __in) + : _Inherited(__tag, __a, + static_cast&>(__in)) + { } + + template() + && !_TMC::template + _ImplicitlyConvertibleTuple<_U1, _U2>(), + bool>::type = false> + explicit tuple(allocator_arg_t __tag, const _Alloc& __a, + const tuple<_U1, _U2>& __in) + : _Inherited(__tag, __a, + static_cast&>(__in)) + { } + + template() + && _TMC::template + _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), + bool>::type = true> + tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) + : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) + { } + + template() + && !_TMC::template + _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), + bool>::type = false> + explicit tuple(allocator_arg_t __tag, const _Alloc& __a, + tuple<_U1, _U2>&& __in) + : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) + { } + + template() + && _TMC::template + _ImplicitlyConvertibleTuple<_U1, _U2>(), + bool>::type = true> + tuple(allocator_arg_t __tag, const _Alloc& __a, + const pair<_U1, _U2>& __in) + : _Inherited(__tag, __a, __in.first, __in.second) { } + + template() + && !_TMC::template + _ImplicitlyConvertibleTuple<_U1, _U2>(), + bool>::type = false> + explicit tuple(allocator_arg_t __tag, const _Alloc& __a, + const pair<_U1, _U2>& __in) + : _Inherited(__tag, __a, __in.first, __in.second) { } + + template() + && _TMC::template + _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), + bool>::type = true> + tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) + : _Inherited(__tag, __a, std::forward<_U1>(__in.first), + std::forward<_U2>(__in.second)) { } + + template() + && !_TMC::template + _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), + bool>::type = false> + explicit tuple(allocator_arg_t __tag, const _Alloc& __a, + pair<_U1, _U2>&& __in) + : _Inherited(__tag, __a, std::forward<_U1>(__in.first), + std::forward<_U2>(__in.second)) { } + + tuple& + operator=(const tuple& __in) + { + static_cast<_Inherited&>(*this) = __in; + return *this; + } + + tuple& + operator=(tuple&& __in) + noexcept(is_nothrow_move_assignable<_Inherited>::value) + { + static_cast<_Inherited&>(*this) = std::move(__in); + return *this; + } + + template + tuple& + operator=(const tuple<_U1, _U2>& __in) + { + static_cast<_Inherited&>(*this) = __in; + return *this; + } + + template + tuple& + operator=(tuple<_U1, _U2>&& __in) + { + static_cast<_Inherited&>(*this) = std::move(__in); + return *this; + } + + template + tuple& + operator=(const pair<_U1, _U2>& __in) + { + this->_M_head(*this) = __in.first; + this->_M_tail(*this)._M_head(*this) = __in.second; + return *this; + } + + template + tuple& + operator=(pair<_U1, _U2>&& __in) + { + this->_M_head(*this) = std::forward<_U1>(__in.first); + this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second); + return *this; + } + + void + swap(tuple& __in) + noexcept(noexcept(__in._M_swap(__in))) + { _Inherited::_M_swap(__in); } + }; + + + + + + + template + struct tuple_element<__i, tuple<_Head, _Tail...> > + : tuple_element<__i - 1, tuple<_Tail...> > { }; + + + + + template + struct tuple_element<0, tuple<_Head, _Tail...> > + { + typedef _Head type; + }; + + + template + struct tuple_size> + : public integral_constant { }; + + template + constexpr _Head& + __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept + { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } + + template + constexpr const _Head& + __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept + { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } + + + template + constexpr __tuple_element_t<__i, tuple<_Elements...>>& + get(tuple<_Elements...>& __t) noexcept + { return std::__get_helper<__i>(__t); } + + + template + constexpr const __tuple_element_t<__i, tuple<_Elements...>>& + get(const tuple<_Elements...>& __t) noexcept + { return std::__get_helper<__i>(__t); } + + + template + constexpr __tuple_element_t<__i, tuple<_Elements...>>&& + get(tuple<_Elements...>&& __t) noexcept + { + typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; + return std::forward<__element_type&&>(std::get<__i>(__t)); + } + + + + + + template + constexpr _Head& + __get_helper2(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept + { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } + + template + constexpr const _Head& + __get_helper2(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept + { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } + + + template + constexpr _Tp& + get(tuple<_Types...>& __t) noexcept + { return std::__get_helper2<_Tp>(__t); } + + + template + constexpr _Tp&& + get(tuple<_Types...>&& __t) noexcept + { return std::forward<_Tp&&>(std::__get_helper2<_Tp>(__t)); } + + + template + constexpr const _Tp& + get(const tuple<_Types...>& __t) noexcept + { return std::__get_helper2<_Tp>(__t); } + + + + template + struct __tuple_compare + { + static constexpr bool + __eq(const _Tp& __t, const _Up& __u) + { + return bool(std::get<__i>(__t) == std::get<__i>(__u)) + && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u); + } + + static constexpr bool + __less(const _Tp& __t, const _Up& __u) + { + return bool(std::get<__i>(__t) < std::get<__i>(__u)) + || (!bool(std::get<__i>(__u) < std::get<__i>(__t)) + && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u)); + } + }; + + template + struct __tuple_compare<_Tp, _Up, __size, __size> + { + static constexpr bool + __eq(const _Tp&, const _Up&) { return true; } + + static constexpr bool + __less(const _Tp&, const _Up&) { return false; } + }; + + template + constexpr bool + operator==(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { + static_assert(sizeof...(_TElements) == sizeof...(_UElements), + "tuple objects can only be compared if they have equal sizes."); + using __compare = __tuple_compare, + tuple<_UElements...>, + 0, sizeof...(_TElements)>; + return __compare::__eq(__t, __u); + } + + template + constexpr bool + operator<(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { + static_assert(sizeof...(_TElements) == sizeof...(_UElements), + "tuple objects can only be compared if they have equal sizes."); + using __compare = __tuple_compare, + tuple<_UElements...>, + 0, sizeof...(_TElements)>; + return __compare::__less(__t, __u); + } + + template + constexpr bool + operator!=(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return !(__t == __u); } + + template + constexpr bool + operator>(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return __u < __t; } + + template + constexpr bool + operator<=(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return !(__u < __t); } + + template + constexpr bool + operator>=(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return !(__t < __u); } + + + template + constexpr tuple::__type...> + make_tuple(_Elements&&... __args) + { + typedef tuple::__type...> + __result_type; + return __result_type(std::forward<_Elements>(__args)...); + } + + + + template + constexpr tuple<_Elements&&...> + forward_as_tuple(_Elements&&... __args) noexcept + { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); } + + template + struct __is_tuple_like_impl> : true_type + { }; + + + template + struct __is_tuple_like + : public __is_tuple_like_impl::type>::type>::type + { }; + + template + struct __make_tuple_impl; + + template + struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm> + : __make_tuple_impl<_Idx + 1, + tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>, + _Tuple, _Nm> + { }; + + template + struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm> + { + typedef tuple<_Tp...> __type; + }; + + template + struct __do_make_tuple + : __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value> + { }; + + + template + struct __make_tuple + : public __do_make_tuple::type>::type> + { }; + + + template + struct __combine_tuples; + + template<> + struct __combine_tuples<> + { + typedef tuple<> __type; + }; + + template + struct __combine_tuples> + { + typedef tuple<_Ts...> __type; + }; + + template + struct __combine_tuples, tuple<_T2s...>, _Rem...> + { + typedef typename __combine_tuples, + _Rem...>::__type __type; + }; + + + template + struct __tuple_cat_result + { + typedef typename __combine_tuples + ::__type...>::__type __type; + }; + + + + template + struct __make_1st_indices; + + template<> + struct __make_1st_indices<> + { + typedef std::_Index_tuple<> __type; + }; + + template + struct __make_1st_indices<_Tp, _Tpls...> + { + typedef typename std::_Build_index_tuple::type>::value>::__type __type; + }; + + + + + template + struct __tuple_concater; + + template + struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...> + { + template + static constexpr _Ret + _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us) + { + typedef typename __make_1st_indices<_Tpls...>::__type __idx; + typedef __tuple_concater<_Ret, __idx, _Tpls...> __next; + return __next::_S_do(std::forward<_Tpls>(__tps)..., + std::forward<_Us>(__us)..., + std::get<_Is>(std::forward<_Tp>(__tp))...); + } + }; + + template + struct __tuple_concater<_Ret, std::_Index_tuple<>> + { + template + static constexpr _Ret + _S_do(_Us&&... __us) + { + return _Ret(std::forward<_Us>(__us)...); + } + }; + + + template...>::value>::type> + constexpr auto + tuple_cat(_Tpls&&... __tpls) + -> typename __tuple_cat_result<_Tpls...>::__type + { + typedef typename __tuple_cat_result<_Tpls...>::__type __ret; + typedef typename __make_1st_indices<_Tpls...>::__type __idx; + typedef __tuple_concater<__ret, __idx, _Tpls...> __concater; + return __concater::_S_do(std::forward<_Tpls>(__tpls)...); + } + + + + + template + constexpr tuple<_Elements&...> + tie(_Elements&... __args) noexcept + { return tuple<_Elements&...>(__args...); } + + + template + inline void + swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } + + + + struct _Swallow_assign + { + template + const _Swallow_assign& + operator=(const _Tp&) const + { return *this; } + }; + + const _Swallow_assign ignore{}; + + + template + struct uses_allocator, _Alloc> : true_type { }; + + + template + template + inline + pair<_T1, _T2>:: + pair(piecewise_construct_t, + tuple<_Args1...> __first, tuple<_Args2...> __second) + : pair(__first, __second, + typename _Build_index_tuple::__type(), + typename _Build_index_tuple::__type()) + { } + + template + template + inline + pair<_T1, _T2>:: + pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>) + : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...), + second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...) + { } + + + + +} +# 56 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 2 3 + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + class _Mem_fn; + template + _Mem_fn<_Tp _Class::*> + mem_fn(_Tp _Class::*) noexcept; + + + template> + struct _Maybe_get_result_type + { }; + + template + struct _Maybe_get_result_type<_Functor, + __void_t> + { typedef typename _Functor::result_type result_type; }; + + + + + + template + struct _Weak_result_type_impl + : _Maybe_get_result_type<_Functor> + { }; + + + template + struct _Weak_result_type_impl<_Res(_ArgTypes...)> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res(_ArgTypes......)> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res(_ArgTypes...) const> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res(_ArgTypes......) const> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile> + { typedef _Res result_type; }; + + + template + struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)> + { typedef _Res result_type; }; + + + template + struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)> + { typedef _Res result_type; }; + + + template + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)> + { typedef _Res result_type; }; + + + template + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const> + { typedef _Res result_type; }; + + + template + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile> + { typedef _Res result_type; }; + + + template + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) + const volatile> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) + const volatile> + { typedef _Res result_type; }; + + + + + + template + struct _Weak_result_type + : _Weak_result_type_impl::type> + { }; + + template::type> + struct __inv_unwrap + { + using type = _Tp; + }; + + template + struct __inv_unwrap<_Tp, reference_wrapper<_Up>> + { + using type = _Up&; + }; + + + + template::type> + inline _Up&& + __invfwd(typename remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Up&&>(__t); } + + template + inline _Res + __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args) + noexcept(noexcept(std::forward<_Fn>(__f)(std::forward<_Args>(__args)...))) + { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); } + + template + inline _Res + __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t, + _Args&&... __args) + noexcept(noexcept( + (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...))) + { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); } + + template + inline _Res + __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t, + _Args&&... __args) + noexcept(noexcept( + ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...))) + { + return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...); + } + + template + inline _Res + __invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t) + noexcept(noexcept(__invfwd<_Tp>(__t).*__f)) + { return __invfwd<_Tp>(__t).*__f; } + + template + inline _Res + __invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t) + noexcept(noexcept((*std::forward<_Tp>(__t)).*__f)) + { return (*std::forward<_Tp>(__t)).*__f; } + + + template + inline typename result_of<_Callable&&(_Args&&...)>::type + __invoke(_Callable&& __fn, _Args&&... __args) + { + using __result_of = result_of<_Callable&&(_Args&&...)>; + using __type = typename __result_of::type; + using __tag = typename __result_of::__invoke_type; + return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), + std::forward<_Args>(__args)...); + } +# 272 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + template + struct _Reference_wrapper_base_impl; + + + template + struct _Reference_wrapper_base_impl + : _Weak_result_type<_Tp> + { }; + + + template + struct _Reference_wrapper_base_impl + : _Weak_result_type<_Tp> + { + typedef typename _Tp::argument_type argument_type; + }; + + + template + struct _Reference_wrapper_base_impl + : _Weak_result_type<_Tp> + { + typedef typename _Tp::first_argument_type first_argument_type; + typedef typename _Tp::second_argument_type second_argument_type; + }; + + + template + struct _Reference_wrapper_base_impl + : _Weak_result_type<_Tp> + { + typedef typename _Tp::argument_type argument_type; + typedef typename _Tp::first_argument_type first_argument_type; + typedef typename _Tp::second_argument_type second_argument_type; + }; + + template> struct __has_argument_type : false_type { }; template struct __has_argument_type<_Tp, __void_t> : true_type { }; + template> struct __has_first_argument_type : false_type { }; template struct __has_first_argument_type<_Tp, __void_t> : true_type { }; + template> struct __has_second_argument_type : false_type { }; template struct __has_second_argument_type<_Tp, __void_t> : true_type { }; + + + + + + + + template + struct _Reference_wrapper_base + : _Reference_wrapper_base_impl< + __has_argument_type<_Tp>::value, + __has_first_argument_type<_Tp>::value + && __has_second_argument_type<_Tp>::value, + _Tp> + { }; + + + template + struct _Reference_wrapper_base<_Res(_T1)> + : unary_function<_T1, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1) const> + : unary_function<_T1, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1) volatile> + : unary_function<_T1, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1) const volatile> + : unary_function<_T1, _Res> + { }; + + + template + struct _Reference_wrapper_base<_Res(_T1, _T2)> + : binary_function<_T1, _T2, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) const> + : binary_function<_T1, _T2, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) volatile> + : binary_function<_T1, _T2, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile> + : binary_function<_T1, _T2, _Res> + { }; + + + template + struct _Reference_wrapper_base<_Res(*)(_T1)> + : unary_function<_T1, _Res> + { }; + + + template + struct _Reference_wrapper_base<_Res(*)(_T1, _T2)> + : binary_function<_T1, _T2, _Res> + { }; + + + template + struct _Reference_wrapper_base<_Res (_T1::*)()> + : unary_function<_T1*, _Res> + { }; + + + template + struct _Reference_wrapper_base<_Res (_T1::*)(_T2)> + : binary_function<_T1*, _T2, _Res> + { }; + + + template + struct _Reference_wrapper_base<_Res (_T1::*)() const> + : unary_function + { }; + + + template + struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const> + : binary_function + { }; + + + template + struct _Reference_wrapper_base<_Res (_T1::*)() volatile> + : unary_function + { }; + + + template + struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile> + : binary_function + { }; + + + template + struct _Reference_wrapper_base<_Res (_T1::*)() const volatile> + : unary_function + { }; + + + template + struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile> + : binary_function + { }; + + + + + + + template + class reference_wrapper + : public _Reference_wrapper_base::type> + { + _Tp* _M_data; + + public: + typedef _Tp type; + + reference_wrapper(_Tp& __indata) noexcept + : _M_data(std::__addressof(__indata)) + { } + + reference_wrapper(_Tp&&) = delete; + + reference_wrapper(const reference_wrapper&) = default; + + reference_wrapper& + operator=(const reference_wrapper&) = default; + + operator _Tp&() const noexcept + { return this->get(); } + + _Tp& + get() const noexcept + { return *_M_data; } + + template + typename result_of<_Tp&(_Args&&...)>::type + operator()(_Args&&... __args) const + { + return std::__invoke(get(), std::forward<_Args>(__args)...); + } + }; + + + + template + inline reference_wrapper<_Tp> + ref(_Tp& __t) noexcept + { return reference_wrapper<_Tp>(__t); } + + + template + inline reference_wrapper + cref(const _Tp& __t) noexcept + { return reference_wrapper(__t); } + + template + void ref(const _Tp&&) = delete; + + template + void cref(const _Tp&&) = delete; + + + template + inline reference_wrapper<_Tp> + ref(reference_wrapper<_Tp> __t) noexcept + { return ref(__t.get()); } + + + template + inline reference_wrapper + cref(reference_wrapper<_Tp> __t) noexcept + { return cref(__t.get()); } + + + + template + struct _Pack : integral_constant + { }; + + template + struct _AllConvertible : false_type + { }; + + template + struct _AllConvertible<_Pack<_From...>, _Pack<_To...>, true> + : __and_...> + { }; + + template + using _NotSame = __not_::type, + typename std::decay<_Tp2>::type>>; + + + + + + + template + struct _Maybe_unary_or_binary_function { }; + + + template + struct _Maybe_unary_or_binary_function<_Res, _T1> + : std::unary_function<_T1, _Res> { }; + + + template + struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> + : std::binary_function<_T1, _T2, _Res> { }; + + template + struct _Mem_fn_traits; + + template + struct _Mem_fn_traits_base + { + using __result_type = _Res; + using __maybe_type + = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>; + using __arity = integral_constant; + }; +# 569 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; + + + + + template::value> + class _Mem_fn_base + : public _Mem_fn_traits<_MemFunPtr>::__maybe_type + { + using _Traits = _Mem_fn_traits<_MemFunPtr>; + + using _Arity = typename _Traits::__arity; + using _Varargs = typename _Traits::__vararg; + + template + friend struct _Bind_check_arity; + + _MemFunPtr _M_pmf; + + public: + + using result_type = typename _Traits::__result_type; + + explicit constexpr + _Mem_fn_base(_MemFunPtr __pmf) noexcept : _M_pmf(__pmf) { } + + template + auto + operator()(_Args&&... __args) const + noexcept(noexcept( + std::__invoke(_M_pmf, std::forward<_Args>(__args)...))) + -> decltype(std::__invoke(_M_pmf, std::forward<_Args>(__args)...)) + { return std::__invoke(_M_pmf, std::forward<_Args>(__args)...); } + }; + + + template + class _Mem_fn_base<_MemObjPtr, false> + { + using _Arity = integral_constant; + using _Varargs = false_type; + + template + friend struct _Bind_check_arity; + + _MemObjPtr _M_pm; + + public: + explicit constexpr + _Mem_fn_base(_MemObjPtr __pm) noexcept : _M_pm(__pm) { } + + template + auto + operator()(_Tp&& __obj) const + noexcept(noexcept(std::__invoke(_M_pm, std::forward<_Tp>(__obj)))) + -> decltype(std::__invoke(_M_pm, std::forward<_Tp>(__obj))) + { return std::__invoke(_M_pm, std::forward<_Tp>(__obj)); } + }; + + template + struct _Mem_fn<_Res _Class::*> + : _Mem_fn_base<_Res _Class::*> + { + using _Mem_fn_base<_Res _Class::*>::_Mem_fn_base; + }; +# 645 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + template + inline _Mem_fn<_Tp _Class::*> + mem_fn(_Tp _Class::* __pm) noexcept + { + return _Mem_fn<_Tp _Class::*>(__pm); + } +# 660 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + template + struct is_bind_expression + : public false_type { }; +# 671 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + template + struct is_placeholder + : public integral_constant + { }; + + + + + template struct _Placeholder { }; + + + + + + + + namespace placeholders + { + + + + + + extern const _Placeholder<1> _1; + extern const _Placeholder<2> _2; + extern const _Placeholder<3> _3; + extern const _Placeholder<4> _4; + extern const _Placeholder<5> _5; + extern const _Placeholder<6> _6; + extern const _Placeholder<7> _7; + extern const _Placeholder<8> _8; + extern const _Placeholder<9> _9; + extern const _Placeholder<10> _10; + extern const _Placeholder<11> _11; + extern const _Placeholder<12> _12; + extern const _Placeholder<13> _13; + extern const _Placeholder<14> _14; + extern const _Placeholder<15> _15; + extern const _Placeholder<16> _16; + extern const _Placeholder<17> _17; + extern const _Placeholder<18> _18; + extern const _Placeholder<19> _19; + extern const _Placeholder<20> _20; + extern const _Placeholder<21> _21; + extern const _Placeholder<22> _22; + extern const _Placeholder<23> _23; + extern const _Placeholder<24> _24; + extern const _Placeholder<25> _25; + extern const _Placeholder<26> _26; + extern const _Placeholder<27> _27; + extern const _Placeholder<28> _28; + extern const _Placeholder<29> _29; + + } +# 733 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + template + struct is_placeholder<_Placeholder<_Num> > + : public integral_constant + { }; + + template + struct is_placeholder > + : public integral_constant + { }; + + + + template + using _Safe_tuple_element_t + = typename enable_if<(__i < tuple_size<_Tuple>::value), + tuple_element<__i, _Tuple>>::type::type; +# 761 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + template::value, + bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)> + class _Mu; + + + + + + + template + class _Mu, false, false> + { + public: + + + + + template + _Tp& + operator()(_CVRef& __arg, _Tuple&) const volatile + { return __arg.get(); } + }; + + + + + + + + template + class _Mu<_Arg, true, false> + { + public: + template + auto + operator()(_CVArg& __arg, + tuple<_Args...>& __tuple) const volatile + -> decltype(__arg(declval<_Args>()...)) + { + + typedef typename _Build_index_tuple::__type + _Indexes; + return this->__call(__arg, __tuple, _Indexes()); + } + + private: + + + template + auto + __call(_CVArg& __arg, tuple<_Args...>& __tuple, + const _Index_tuple<_Indexes...>&) const volatile + -> decltype(__arg(declval<_Args>()...)) + { + return __arg(std::forward<_Args>(std::get<_Indexes>(__tuple))...); + } + }; + + + + + + + template + class _Mu<_Arg, false, true> + { + public: + template + _Safe_tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>&& + operator()(const volatile _Arg&, _Tuple& __tuple) const volatile + { + using __type + = __tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>; + return std::forward<__type>( + ::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple)); + } + }; + + + + + + + template + class _Mu<_Arg, false, false> + { + public: + template + _CVArg&& + operator()(_CVArg&& __arg, _Tuple&) const volatile + { return std::forward<_CVArg>(__arg); } + }; + + + + + + + template + struct _Maybe_wrap_member_pointer + { + typedef _Tp type; + + static constexpr const _Tp& + __do_wrap(const _Tp& __x) + { return __x; } + + static constexpr _Tp&& + __do_wrap(_Tp&& __x) + { return static_cast<_Tp&&>(__x); } + }; + + + + + + + template + struct _Maybe_wrap_member_pointer<_Tp _Class::*> + { + typedef _Mem_fn<_Tp _Class::*> type; + + static constexpr type + __do_wrap(_Tp _Class::* __pm) + { return type(__pm); } + }; + + + + + + template<> + struct _Maybe_wrap_member_pointer + { + typedef void type; + }; + + + template + inline auto + __volget(volatile tuple<_Tp...>& __tuple) + -> __tuple_element_t<_Ind, tuple<_Tp...>> volatile& + { return std::get<_Ind>(const_cast&>(__tuple)); } + + + template + inline auto + __volget(const volatile tuple<_Tp...>& __tuple) + -> __tuple_element_t<_Ind, tuple<_Tp...>> const volatile& + { return std::get<_Ind>(const_cast&>(__tuple)); } + + + template + struct _Bind; + + template + class _Bind<_Functor(_Bound_args...)> + : public _Weak_result_type<_Functor> + { + typedef _Bind __self_type; + typedef typename _Build_index_tuple::__type + _Bound_indexes; + + _Functor _M_f; + tuple<_Bound_args...> _M_bound_args; + + + template + _Result + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) + { + return _M_f(_Mu<_Bound_args>() + (std::get<_Indexes>(_M_bound_args), __args)...); + } + + + template + _Result + __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const + { + return _M_f(_Mu<_Bound_args>() + (std::get<_Indexes>(_M_bound_args), __args)...); + } + + + template + _Result + __call_v(tuple<_Args...>&& __args, + _Index_tuple<_Indexes...>) volatile + { + return _M_f(_Mu<_Bound_args>() + (__volget<_Indexes>(_M_bound_args), __args)...); + } + + + template + _Result + __call_c_v(tuple<_Args...>&& __args, + _Index_tuple<_Indexes...>) const volatile + { + return _M_f(_Mu<_Bound_args>() + (__volget<_Indexes>(_M_bound_args), __args)...); + } + + public: + template + explicit _Bind(const _Functor& __f, _Args&&... __args) + : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...) + { } + + template + explicit _Bind(_Functor&& __f, _Args&&... __args) + : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...) + { } + + _Bind(const _Bind&) = default; + + _Bind(_Bind&& __b) + : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args)) + { } + + + template()( + _Mu<_Bound_args>()( std::declval<_Bound_args&>(), + std::declval&>() )... ) )> + _Result + operator()(_Args&&... __args) + { + return this->__call<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } + + + template= 0), + typename add_const<_Functor>::type&>::type>()( + _Mu<_Bound_args>()( std::declval(), + std::declval&>() )... ) )> + _Result + operator()(_Args&&... __args) const + { + return this->__call_c<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } + + + template= 0), + typename add_volatile<_Functor>::type&>::type>()( + _Mu<_Bound_args>()( std::declval(), + std::declval&>() )... ) )> + _Result + operator()(_Args&&... __args) volatile + { + return this->__call_v<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } + + + template= 0), + typename add_cv<_Functor>::type&>::type>()( + _Mu<_Bound_args>()( std::declval(), + std::declval&>() )... ) )> + _Result + operator()(_Args&&... __args) const volatile + { + return this->__call_c_v<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } + }; + + + template + struct _Bind_result; + + template + class _Bind_result<_Result, _Functor(_Bound_args...)> + { + typedef _Bind_result __self_type; + typedef typename _Build_index_tuple::__type + _Bound_indexes; + + _Functor _M_f; + tuple<_Bound_args...> _M_bound_args; + + + template + struct __enable_if_void : enable_if::value, int> { }; + template + struct __disable_if_void : enable_if::value, int> { }; + + + template + _Result + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __disable_if_void<_Res>::type = 0) + { + return _M_f(_Mu<_Bound_args>() + (std::get<_Indexes>(_M_bound_args), __args)...); + } + + + template + void + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __enable_if_void<_Res>::type = 0) + { + _M_f(_Mu<_Bound_args>() + (std::get<_Indexes>(_M_bound_args), __args)...); + } + + + template + _Result + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __disable_if_void<_Res>::type = 0) const + { + return _M_f(_Mu<_Bound_args>() + (std::get<_Indexes>(_M_bound_args), __args)...); + } + + + template + void + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __enable_if_void<_Res>::type = 0) const + { + _M_f(_Mu<_Bound_args>() + (std::get<_Indexes>(_M_bound_args), __args)...); + } + + + template + _Result + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __disable_if_void<_Res>::type = 0) volatile + { + return _M_f(_Mu<_Bound_args>() + (__volget<_Indexes>(_M_bound_args), __args)...); + } + + + template + void + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __enable_if_void<_Res>::type = 0) volatile + { + _M_f(_Mu<_Bound_args>() + (__volget<_Indexes>(_M_bound_args), __args)...); + } + + + template + _Result + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __disable_if_void<_Res>::type = 0) const volatile + { + return _M_f(_Mu<_Bound_args>() + (__volget<_Indexes>(_M_bound_args), __args)...); + } + + + template + void + __call(tuple<_Args...>&& __args, + _Index_tuple<_Indexes...>, + typename __enable_if_void<_Res>::type = 0) const volatile + { + _M_f(_Mu<_Bound_args>() + (__volget<_Indexes>(_M_bound_args), __args)...); + } + + public: + typedef _Result result_type; + + template + explicit _Bind_result(const _Functor& __f, _Args&&... __args) + : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...) + { } + + template + explicit _Bind_result(_Functor&& __f, _Args&&... __args) + : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...) + { } + + _Bind_result(const _Bind_result&) = default; + + _Bind_result(_Bind_result&& __b) + : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args)) + { } + + + template + result_type + operator()(_Args&&... __args) + { + return this->__call<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } + + + template + result_type + operator()(_Args&&... __args) const + { + return this->__call<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } + + + template + result_type + operator()(_Args&&... __args) volatile + { + return this->__call<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } + + + template + result_type + operator()(_Args&&... __args) const volatile + { + return this->__call<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } + }; + + + + + + template + struct is_bind_expression<_Bind<_Signature> > + : public true_type { }; + + + + + + template + struct is_bind_expression > + : public true_type { }; + + + + + + template + struct is_bind_expression > + : public true_type { }; + + + + + + template + struct is_bind_expression> + : public true_type { }; + + + + + + template + struct is_bind_expression<_Bind_result<_Result, _Signature>> + : public true_type { }; + + + + + + template + struct is_bind_expression> + : public true_type { }; + + + + + + template + struct is_bind_expression> + : public true_type { }; + + + + + + template + struct is_bind_expression> + : public true_type { }; + + template + struct _Bind_check_arity { }; + + template + struct _Bind_check_arity<_Ret (*)(_Args...), _BoundArgs...> + { + static_assert(sizeof...(_BoundArgs) == sizeof...(_Args), + "Wrong number of arguments for function"); + }; + + template + struct _Bind_check_arity<_Ret (*)(_Args......), _BoundArgs...> + { + static_assert(sizeof...(_BoundArgs) >= sizeof...(_Args), + "Wrong number of arguments for function"); + }; + + template + struct _Bind_check_arity<_Tp _Class::*, _BoundArgs...> + { + using _Arity = typename _Mem_fn<_Tp _Class::*>::_Arity; + using _Varargs = typename _Mem_fn<_Tp _Class::*>::_Varargs; + static_assert(_Varargs::value + ? sizeof...(_BoundArgs) >= _Arity::value + 1 + : sizeof...(_BoundArgs) == _Arity::value + 1, + "Wrong number of arguments for pointer-to-member"); + }; + + + + + template::type> + using __is_socketlike = __or_, is_enum<_Tp2>>; + + template + struct _Bind_helper + : _Bind_check_arity::type, _BoundArgs...> + { + typedef _Maybe_wrap_member_pointer::type> + __maybe_type; + typedef typename __maybe_type::type __func_type; + typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type; + }; + + + + + template + struct _Bind_helper + { }; + + + + + + template + inline typename + _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type + bind(_Func&& __f, _BoundArgs&&... __args) + { + typedef _Bind_helper __helper_type; + typedef typename __helper_type::__maybe_type __maybe_type; + typedef typename __helper_type::type __result_type; + return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)), + std::forward<_BoundArgs>(__args)...); + } + + template + struct _Bindres_helper + : _Bind_check_arity::type, _BoundArgs...> + { + typedef _Maybe_wrap_member_pointer::type> + __maybe_type; + typedef typename __maybe_type::type __functor_type; + typedef _Bind_result<_Result, + __functor_type(typename decay<_BoundArgs>::type...)> + type; + }; + + + + + + template + inline + typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type + bind(_Func&& __f, _BoundArgs&&... __args) + { + typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type; + typedef typename __helper_type::__maybe_type __maybe_type; + typedef typename __helper_type::type __result_type; + return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)), + std::forward<_BoundArgs>(__args)...); + } + + template + struct _Bind_simple; + + template + struct _Bind_simple<_Callable(_Args...)> + { + typedef typename result_of<_Callable(_Args...)>::type result_type; + + template + explicit + _Bind_simple(_Tp&& __f, _Up&&... __args) + : _M_bound(std::forward<_Tp>(__f), std::forward<_Up>(__args)...) + { } + + _Bind_simple(const _Bind_simple&) = default; + _Bind_simple(_Bind_simple&&) = default; + + result_type + operator()() + { + typedef typename _Build_index_tuple::__type _Indices; + return _M_invoke(_Indices()); + } + + private: + template + typename result_of<_Callable(_Args...)>::type + _M_invoke(_Index_tuple<_Indices...>) + { + + + return std::forward<_Callable>(std::get<0>(_M_bound))( + std::forward<_Args>(std::get<_Indices+1>(_M_bound))...); + } + + std::tuple<_Callable, _Args...> _M_bound; + }; + + template + struct _Bind_simple_helper + : _Bind_check_arity::type, _BoundArgs...> + { + typedef _Maybe_wrap_member_pointer::type> + __maybe_type; + typedef typename __maybe_type::type __func_type; + typedef _Bind_simple<__func_type(typename decay<_BoundArgs>::type...)> + __type; + }; + + + + template + typename _Bind_simple_helper<_Callable, _Args...>::__type + __bind_simple(_Callable&& __callable, _Args&&... __args) + { + typedef _Bind_simple_helper<_Callable, _Args...> __helper_type; + typedef typename __helper_type::__maybe_type __maybe_type; + typedef typename __helper_type::__type __result_type; + return __result_type( + __maybe_type::__do_wrap( std::forward<_Callable>(__callable)), + std::forward<_Args>(__args)...); + } + + + + + + + class bad_function_call : public std::exception + { + public: + virtual ~bad_function_call() noexcept; + + const char* what() const noexcept; + }; + + + + + + + + template + struct __is_location_invariant + : is_trivially_copyable<_Tp>::type + { }; + + class _Undefined_class; + + union _Nocopy_types + { + void* _M_object; + const void* _M_const_object; + void (*_M_function_pointer)(); + void (_Undefined_class::*_M_member_pointer)(); + }; + + union [[gnu::may_alias]] _Any_data + { + void* _M_access() { return &_M_pod_data[0]; } + const void* _M_access() const { return &_M_pod_data[0]; } + + template + _Tp& + _M_access() + { return *static_cast<_Tp*>(_M_access()); } + + template + const _Tp& + _M_access() const + { return *static_cast(_M_access()); } + + _Nocopy_types _M_unused; + char _M_pod_data[sizeof(_Nocopy_types)]; + }; + + enum _Manager_operation + { + __get_type_info, + __get_functor_ptr, + __clone_functor, + __destroy_functor + }; + + + + template + struct _Simple_type_wrapper + { + _Simple_type_wrapper(_Tp __value) : __value(__value) { } + + _Tp __value; + }; + + template + struct __is_location_invariant<_Simple_type_wrapper<_Tp> > + : __is_location_invariant<_Tp> + { }; + + + + template + inline _Functor& + __callable_functor(_Functor& __f) + { return __f; } + + template + inline _Mem_fn<_Member _Class::*> + __callable_functor(_Member _Class::* &__p) + { return std::mem_fn(__p); } + + template + inline _Mem_fn<_Member _Class::*> + __callable_functor(_Member _Class::* const &__p) + { return std::mem_fn(__p); } + + template + inline _Mem_fn<_Member _Class::*> + __callable_functor(_Member _Class::* volatile &__p) + { return std::mem_fn(__p); } + + template + inline _Mem_fn<_Member _Class::*> + __callable_functor(_Member _Class::* const volatile &__p) + { return std::mem_fn(__p); } + + template + class function; + + + class _Function_base + { + public: + static const std::size_t _M_max_size = sizeof(_Nocopy_types); + static const std::size_t _M_max_align = __alignof__(_Nocopy_types); + + template + class _Base_manager + { + protected: + static const bool __stored_locally = + (__is_location_invariant<_Functor>::value + && sizeof(_Functor) <= _M_max_size + && __alignof__(_Functor) <= _M_max_align + && (_M_max_align % __alignof__(_Functor) == 0)); + + typedef integral_constant _Local_storage; + + + static _Functor* + _M_get_pointer(const _Any_data& __source) + { + const _Functor* __ptr = + __stored_locally? std::__addressof(__source._M_access<_Functor>()) + : __source._M_access<_Functor*>(); + return const_cast<_Functor*>(__ptr); + } + + + + static void + _M_clone(_Any_data& __dest, const _Any_data& __source, true_type) + { + ::new (__dest._M_access()) _Functor(__source._M_access<_Functor>()); + } + + + + static void + _M_clone(_Any_data& __dest, const _Any_data& __source, false_type) + { + __dest._M_access<_Functor*>() = + new _Functor(*__source._M_access<_Functor*>()); + } + + + + static void + _M_destroy(_Any_data& __victim, true_type) + { + __victim._M_access<_Functor>().~_Functor(); + } + + + static void + _M_destroy(_Any_data& __victim, false_type) + { + delete __victim._M_access<_Functor*>(); + } + + public: + static bool + _M_manager(_Any_data& __dest, const _Any_data& __source, + _Manager_operation __op) + { + switch (__op) + { + + case __get_type_info: + __dest._M_access() = &typeid(_Functor); + break; + + case __get_functor_ptr: + __dest._M_access<_Functor*>() = _M_get_pointer(__source); + break; + + case __clone_functor: + _M_clone(__dest, __source, _Local_storage()); + break; + + case __destroy_functor: + _M_destroy(__dest, _Local_storage()); + break; + } + return false; + } + + static void + _M_init_functor(_Any_data& __functor, _Functor&& __f) + { _M_init_functor(__functor, std::move(__f), _Local_storage()); } + + template + static bool + _M_not_empty_function(const function<_Signature>& __f) + { return static_cast(__f); } + + template + static bool + _M_not_empty_function(_Tp* __fp) + { return __fp != nullptr; } + + template + static bool + _M_not_empty_function(_Tp _Class::* __mp) + { return __mp != nullptr; } + + template + static bool + _M_not_empty_function(const _Tp&) + { return true; } + + private: + static void + _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type) + { ::new (__functor._M_access()) _Functor(std::move(__f)); } + + static void + _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type) + { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); } + }; + + template + class _Ref_manager : public _Base_manager<_Functor*> + { + typedef _Function_base::_Base_manager<_Functor*> _Base; + + public: + static bool + _M_manager(_Any_data& __dest, const _Any_data& __source, + _Manager_operation __op) + { + switch (__op) + { + + case __get_type_info: + __dest._M_access() = &typeid(_Functor); + break; + + case __get_functor_ptr: + __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source); + return is_const<_Functor>::value; + break; + + default: + _Base::_M_manager(__dest, __source, __op); + } + return false; + } + + static void + _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f) + { + _Base::_M_init_functor(__functor, std::__addressof(__f.get())); + } + }; + + _Function_base() : _M_manager(nullptr) { } + + ~_Function_base() + { + if (_M_manager) + _M_manager(_M_functor, _M_functor, __destroy_functor); + } + + + bool _M_empty() const { return !_M_manager; } + + typedef bool (*_Manager_type)(_Any_data&, const _Any_data&, + _Manager_operation); + + _Any_data _M_functor; + _Manager_type _M_manager; + }; + + template + class _Function_handler; + + template + class _Function_handler<_Res(_ArgTypes...), _Functor> + : public _Function_base::_Base_manager<_Functor> + { + typedef _Function_base::_Base_manager<_Functor> _Base; + + public: + static _Res + _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) + { + return (*_Base::_M_get_pointer(__functor))( + std::forward<_ArgTypes>(__args)...); + } + }; + + template + class _Function_handler + : public _Function_base::_Base_manager<_Functor> + { + typedef _Function_base::_Base_manager<_Functor> _Base; + + public: + static void + _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) + { + (*_Base::_M_get_pointer(__functor))( + std::forward<_ArgTypes>(__args)...); + } + }; + + template + class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> > + : public _Function_base::_Ref_manager<_Functor> + { + typedef _Function_base::_Ref_manager<_Functor> _Base; + + public: + static _Res + _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) + { + return std::__callable_functor(**_Base::_M_get_pointer(__functor))( + std::forward<_ArgTypes>(__args)...); + } + }; + + template + class _Function_handler > + : public _Function_base::_Ref_manager<_Functor> + { + typedef _Function_base::_Ref_manager<_Functor> _Base; + + public: + static void + _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) + { + std::__callable_functor(**_Base::_M_get_pointer(__functor))( + std::forward<_ArgTypes>(__args)...); + } + }; + + template + class _Function_handler<_Res(_ArgTypes...), _Member _Class::*> + : public _Function_handler + { + typedef _Function_handler + _Base; + + public: + static _Res + _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) + { + return std::mem_fn(_Base::_M_get_pointer(__functor)->__value)( + std::forward<_ArgTypes>(__args)...); + } + }; + + template + class _Function_handler + : public _Function_base::_Base_manager< + _Simple_type_wrapper< _Member _Class::* > > + { + typedef _Member _Class::* _Functor; + typedef _Simple_type_wrapper<_Functor> _Wrapper; + typedef _Function_base::_Base_manager<_Wrapper> _Base; + + public: + static bool + _M_manager(_Any_data& __dest, const _Any_data& __source, + _Manager_operation __op) + { + switch (__op) + { + + case __get_type_info: + __dest._M_access() = &typeid(_Functor); + break; + + case __get_functor_ptr: + __dest._M_access<_Functor*>() = + &_Base::_M_get_pointer(__source)->__value; + break; + + default: + _Base::_M_manager(__dest, __source, __op); + } + return false; + } + + static void + _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) + { + std::mem_fn(_Base::_M_get_pointer(__functor)->__value)( + std::forward<_ArgTypes>(__args)...); + } + }; + + template + using __check_func_return_type + = __or_, is_same<_From, _To>, is_convertible<_From, _To>>; + + + + + + + + template + class function<_Res(_ArgTypes...)> + : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>, + private _Function_base + { + typedef _Res _Signature_type(_ArgTypes...); + + template::type> + struct _Callable : __check_func_return_type<_Res2, _Res> { }; + + + + template + struct _Callable : false_type { }; + + template + using _Requires = typename enable_if<_Cond::value, _Tp>::type; + + public: + typedef _Res result_type; + + + + + + + + function() noexcept + : _Function_base() { } + + + + + + function(nullptr_t) noexcept + : _Function_base() { } +# 1879 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + function(const function& __x); +# 1888 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + function(function&& __x) : _Function_base() + { + __x.swap(*this); + } +# 1911 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + template>, void>, + typename = _Requires<_Callable<_Functor>, void>> + function(_Functor); +# 1928 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + function& + operator=(const function& __x) + { + function(__x).swap(*this); + return *this; + } +# 1946 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + function& + operator=(function&& __x) + { + function(std::move(__x)).swap(*this); + return *this; + } +# 1960 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + function& + operator=(nullptr_t) noexcept + { + if (_M_manager) + { + _M_manager(_M_functor, _M_functor, __destroy_functor); + _M_manager = nullptr; + _M_invoker = nullptr; + } + return *this; + } +# 1988 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + template + _Requires<_Callable::type>, function&> + operator=(_Functor&& __f) + { + function(std::forward<_Functor>(__f)).swap(*this); + return *this; + } + + + template + function& + operator=(reference_wrapper<_Functor> __f) noexcept + { + function(__f).swap(*this); + return *this; + } +# 2014 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + void swap(function& __x) noexcept + { + std::swap(_M_functor, __x._M_functor); + std::swap(_M_manager, __x._M_manager); + std::swap(_M_invoker, __x._M_invoker); + } +# 2042 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + explicit operator bool() const noexcept + { return !_M_empty(); } +# 2055 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + _Res operator()(_ArgTypes... __args) const; +# 2068 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + const type_info& target_type() const noexcept; +# 2079 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + template _Functor* target() noexcept; + + + template const _Functor* target() const noexcept; + + + private: + using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...); + _Invoker_type _M_invoker; + }; + + + template + function<_Res(_ArgTypes...)>:: + function(const function& __x) + : _Function_base() + { + if (static_cast(__x)) + { + __x._M_manager(_M_functor, __x._M_functor, __clone_functor); + _M_invoker = __x._M_invoker; + _M_manager = __x._M_manager; + } + } + + template + template + function<_Res(_ArgTypes...)>:: + function(_Functor __f) + : _Function_base() + { + typedef _Function_handler<_Signature_type, _Functor> _My_handler; + + if (_My_handler::_M_not_empty_function(__f)) + { + _My_handler::_M_init_functor(_M_functor, std::move(__f)); + _M_invoker = &_My_handler::_M_invoke; + _M_manager = &_My_handler::_M_manager; + } + } + + template + _Res + function<_Res(_ArgTypes...)>:: + operator()(_ArgTypes... __args) const + { + if (_M_empty()) + __throw_bad_function_call(); + return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...); + } + + + template + const type_info& + function<_Res(_ArgTypes...)>:: + target_type() const noexcept + { + if (_M_manager) + { + _Any_data __typeinfo_result; + _M_manager(__typeinfo_result, _M_functor, __get_type_info); + return *__typeinfo_result._M_access(); + } + else + return typeid(void); + } + + template + template + _Functor* + function<_Res(_ArgTypes...)>:: + target() noexcept + { + if (typeid(_Functor) == target_type() && _M_manager) + { + _Any_data __ptr; + if (_M_manager(__ptr, _M_functor, __get_functor_ptr) + && !is_const<_Functor>::value) + return 0; + else + return __ptr._M_access<_Functor*>(); + } + else + return 0; + } + + template + template + const _Functor* + function<_Res(_ArgTypes...)>:: + target() const noexcept + { + if (typeid(_Functor) == target_type() && _M_manager) + { + _Any_data __ptr; + _M_manager(__ptr, _M_functor, __get_functor_ptr); + return __ptr._M_access(); + } + else + return 0; + } +# 2191 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + template + inline bool + operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept + { return !static_cast(__f); } + + + template + inline bool + operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept + { return !static_cast(__f); } +# 2209 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + template + inline bool + operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept + { return static_cast(__f); } + + + template + inline bool + operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept + { return static_cast(__f); } +# 2229 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3 + template + inline void + swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept + { __x.swap(__y); } + + +} +# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2 + + + +namespace JS { +template +class Heap; +} + +class nsRegion; +namespace mozilla { +namespace layers { +struct TileClient; +} +} + +namespace mozilla { +struct SerializedStructuredCloneBuffer; +class SourceBufferTask; +} + +namespace mozilla { +namespace dom { +namespace ipc { +class StructuredCloneData; +} +} +} + +namespace mozilla { +namespace dom { +class ClonedMessageData; +class MessagePortMessage; +namespace indexedDB { +struct StructuredCloneReadInfo; +class SerializedStructuredCloneReadInfo; +class ObjectStoreCursorResponse; +} +} +} + +class JSStructuredCloneData; +# 137 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" +struct nsTArrayFallibleResult +{ + + nsTArrayFallibleResult(bool aResult) : mResult(aResult) {} + + operator bool() { return mResult; } + +private: + bool mResult; +}; + +struct nsTArrayInfallibleResult +{ +}; + + + + + + +struct nsTArrayFallibleAllocatorBase +{ + typedef bool ResultType; + typedef nsTArrayFallibleResult ResultTypeProxy; + + static ResultType Result(ResultTypeProxy aResult) { return aResult; } + static bool Successful(ResultTypeProxy aResult) { return aResult; } + static ResultTypeProxy SuccessResult() { return true; } + static ResultTypeProxy FailureResult() { return false; } + static ResultType ConvertBoolToResultType(bool aValue) { return aValue; } +}; + +struct nsTArrayInfallibleAllocatorBase +{ + typedef void ResultType; + typedef nsTArrayInfallibleResult ResultTypeProxy; + + static ResultType Result(ResultTypeProxy aResult) {} + static bool Successful(ResultTypeProxy) { return true; } + static ResultTypeProxy SuccessResult() { return ResultTypeProxy(); } + + static ResultTypeProxy FailureResult() + { + do { AnnotateMozCrashReason("MOZ_CRASH(" "Infallible nsTArray should never fail" ")"); do { *((volatile int*) __null) = 180; ::abort(); } while (0); } while (0); + return ResultTypeProxy(); + } + + static ResultType ConvertBoolToResultType(bool aValue) + { + if (!aValue) { + do { AnnotateMozCrashReason("MOZ_CRASH(" "infallible nsTArray should never convert false to ResultType" ")"); do { *((volatile int*) __null) = 187; ::abort(); } while (0); } while (0); + } + } +}; + +struct nsTArrayFallibleAllocator : nsTArrayFallibleAllocatorBase +{ + static void* Malloc(size_t aSize) { return malloc(aSize); } + static void* Realloc(void* aPtr, size_t aSize) + { + return realloc(aPtr, aSize); + } + + static void Free(void* aPtr) { free(aPtr); } + static void SizeTooBig(size_t) {} +}; + + + + +struct nsTArrayInfallibleAllocator : nsTArrayInfallibleAllocatorBase +{ + static void* Malloc(size_t aSize) { return moz_xmalloc(aSize); } + static void* Realloc(void* aPtr, size_t aSize) + { + return moz_xrealloc(aPtr, aSize); + } + + static void Free(void* aPtr) { free(aPtr); } + static void SizeTooBig(size_t aSize) { NS_ABORT_OOM(aSize); } +}; +# 251 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" +struct nsTArrayHeader +{ + static nsTArrayHeader sEmptyHdr; + + uint32_t mLength; + uint32_t mCapacity : 31; + uint32_t mIsAutoArray : 1; +}; + + + +template +struct nsTArray_SafeElementAtHelper +{ + typedef E* elem_type; + typedef size_t index_type; + + + + + elem_type& SafeElementAt(index_type aIndex); + const elem_type& SafeElementAt(index_type aIndex) const; +}; + +template +struct nsTArray_SafeElementAtHelper +{ + typedef E* elem_type; + + typedef size_t index_type; + + elem_type SafeElementAt(index_type aIndex) + { + return static_cast(this)->SafeElementAt(aIndex, nullptr); + } + + + + + + elem_type SafeElementAt(index_type aIndex) const + { + return static_cast(this)->SafeElementAt(aIndex, nullptr); + } +}; + + + +template +struct nsTArray_SafeElementAtSmartPtrHelper +{ + typedef E* elem_type; + typedef const E* const_elem_type; + typedef size_t index_type; + + elem_type SafeElementAt(index_type aIndex) + { + return static_cast(this)->SafeElementAt(aIndex, nullptr); + } + + + elem_type SafeElementAt(index_type aIndex) const + { + return static_cast(this)->SafeElementAt(aIndex, nullptr); + } +}; + +template class nsCOMPtr; + +template +struct nsTArray_SafeElementAtHelper, Derived> + : public nsTArray_SafeElementAtSmartPtrHelper +{ +}; + +template +struct nsTArray_SafeElementAtHelper, Derived> + : public nsTArray_SafeElementAtSmartPtrHelper +{ +}; + +namespace mozilla { +template class OwningNonNull; +} + +template +struct nsTArray_SafeElementAtHelper, Derived> +{ + typedef E* elem_type; + typedef const E* const_elem_type; + typedef size_t index_type; + + elem_type SafeElementAt(index_type aIndex) + { + if (aIndex < static_cast(this)->Length()) { + return static_cast(this)->ElementAt(aIndex); + } + return nullptr; + } + + + elem_type SafeElementAt(index_type aIndex) const + { + if (aIndex < static_cast(this)->Length()) { + return static_cast(this)->ElementAt(aIndex); + } + return nullptr; + } +}; + + +extern "C" void Gecko_EnsureTArrayCapacity(void* aArray, + size_t aCapacity, + size_t aElementSize); +extern "C" void Gecko_ClearPODTArray(void* aArray, + size_t aElementSize, + size_t aElementAlign); + +__attribute__((noreturn)) __attribute__ ((cold)) void +InvalidArrayIndex_CRASH(size_t aIndex, size_t aLength); + + + + + + +template +class nsTArray_base +{ + + + + template + friend class nsTArray_base; + friend void Gecko_EnsureTArrayCapacity(void* aArray, size_t aCapacity, + size_t aElemSize); + friend void Gecko_ClearPODTArray(void* aTArray, size_t aElementSize, + size_t aElementAlign); + +protected: + typedef nsTArrayHeader Header; + +public: + typedef size_t size_type; + typedef size_t index_type; + + + size_type Length() const { return mHdr->mLength; } + + + bool IsEmpty() const { return Length() == 0; } + + + + + size_type Capacity() const { return mHdr->mCapacity; } + + + + + +protected: + nsTArray_base(); + + ~nsTArray_base(); + + + + + + template + typename ActualAlloc::ResultTypeProxy EnsureCapacity(size_type aCapacity, + size_type aElemSize); + + + + + + void ShrinkCapacity(size_type aElemSize, size_t aElemAlign); +# 439 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" + template + void ShiftData(index_type aStart, size_type aOldLen, size_type aNewLen, + size_type aElemSize, size_t aElemAlign); + + + + + + void IncrementLength(size_t aNum) + { + if (mHdr == EmptyHdr()) { + if ((__builtin_expect(!!(aNum != 0), 0))) { + + do { AnnotateMozCrashReason("MOZ_CRASH(" ")"); do { *((volatile int*) __null) = 452; ::abort(); } while (0); } while (0); + } + } else { + mHdr->mLength += aNum; + } + } + + + + + + + + template + bool InsertSlotsAt(index_type aIndex, size_type aCount, + size_type aElementSize, size_t aElemAlign); + + template + typename ActualAlloc::ResultTypeProxy + SwapArrayElements(nsTArray_base& aOther, + size_type aElemSize, + size_t aElemAlign); + + + class IsAutoArrayRestorer + { + public: + IsAutoArrayRestorer(nsTArray_base& aArray, size_t aElemAlign); + ~IsAutoArrayRestorer(); + + private: + nsTArray_base& mArray; + size_t mElemAlign; + bool mIsAuto; + }; + + + + template + bool EnsureNotUsingAutoArrayBuffer(size_type aElemSize); + + + bool IsAutoArray() const { return mHdr->mIsAutoArray; } + + + Header* GetAutoArrayBuffer(size_t aElemAlign) + { + do { } while (0); + return GetAutoArrayBufferUnsafe(aElemAlign); + } + const Header* GetAutoArrayBuffer(size_t aElemAlign) const + { + do { } while (0); + return GetAutoArrayBufferUnsafe(aElemAlign); + } + + + + Header* GetAutoArrayBufferUnsafe(size_t aElemAlign) + { + return const_cast(static_cast*>( + this)->GetAutoArrayBufferUnsafe(aElemAlign)); + } + const Header* GetAutoArrayBufferUnsafe(size_t aElemAlign) const; + + + + bool UsesAutoArrayBuffer() const; + + + + Header* mHdr; + + Header* Hdr() const { return mHdr; } + Header** PtrToHdr() { return &mHdr; } + static Header* EmptyHdr() { return &Header::sEmptyHdr; } +}; + + + + + +template +class nsTArrayElementTraits +{ +public: + + static inline void Construct(E* aE) + { + + + + + + new (static_cast(aE)) E; + } + + template + static inline void Construct(E* aE, A&& aArg) + { + typedef typename mozilla::RemoveCV::Type E_NoCV; + typedef typename mozilla::RemoveCV::Type A_NoCV; + static_assert(!mozilla::IsSame::value, + "For safety, we disallow constructing nsTArray elements " + "from E* pointers. See bug 960591."); + new (static_cast(aE)) E(mozilla::Forward(aArg)); + } + + static inline void Destruct(E* aE) { aE->~E(); } +}; + + +template +class nsDefaultComparator +{ +public: + bool Equals(const A& aA, const B& aB) const { return aA == aB; } + bool LessThan(const A& aA, const B& aB) const { return aA < aB; } +}; + +template +struct AssignRangeAlgorithm +{ + template + static void implementation(ElemType* aElements, IndexType aStart, + SizeType aCount, const Item* aValues) + { + ElemType* iter = aElements + aStart; + ElemType* end = iter + aCount; + for (; iter != end; ++iter, ++aValues) { + nsTArrayElementTraits::Construct(iter, *aValues); + } + } +}; + +template<> +struct AssignRangeAlgorithm +{ + template + static void implementation(ElemType* aElements, IndexType aStart, + SizeType aCount, const Item* aValues) + { + memcpy(aElements + aStart, aValues, aCount * sizeof(ElemType)); + } +}; +# 608 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" +struct nsTArray_CopyWithMemutils +{ + const static bool allowRealloc = true; + + static void MoveNonOverlappingRegionWithHeader(void* aDest, const void* aSrc, + size_t aCount, size_t aElemSize) + { + memcpy(aDest, aSrc, sizeof(nsTArrayHeader) + aCount * aElemSize); + } + + static void MoveOverlappingRegion(void* aDest, void* aSrc, size_t aCount, + size_t aElemSize) + { + memmove(aDest, aSrc, aCount * aElemSize); + } + + static void MoveNonOverlappingRegion(void* aDest, void* aSrc, size_t aCount, + size_t aElemSize) + { + memcpy(aDest, aSrc, aCount * aElemSize); + } +}; + + + + + +template +struct nsTArray_CopyWithConstructors +{ + typedef nsTArrayElementTraits traits; + + const static bool allowRealloc = false; + + static void MoveNonOverlappingRegionWithHeader(void* aDest, void* aSrc, size_t aCount, + size_t aElemSize) + { + nsTArrayHeader* destHeader = static_cast(aDest); + nsTArrayHeader* srcHeader = static_cast(aSrc); + *destHeader = *srcHeader; + MoveNonOverlappingRegion(static_cast(aDest) + sizeof(nsTArrayHeader), + static_cast(aSrc) + sizeof(nsTArrayHeader), + aCount, aElemSize); + } +# 662 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" + static void MoveOverlappingRegion(void* aDest, void* aSrc, size_t aCount, + size_t aElemSize) + { + ElemType* destElem = static_cast(aDest); + ElemType* srcElem = static_cast(aSrc); + ElemType* destElemEnd = destElem + aCount; + ElemType* srcElemEnd = srcElem + aCount; + if (destElem == srcElem) { + return; + } + + + if (srcElemEnd > destElem && srcElemEnd < destElemEnd) { + while (destElemEnd != destElem) { + --destElemEnd; + --srcElemEnd; + traits::Construct(destElemEnd, mozilla::Move(*srcElemEnd)); + traits::Destruct(srcElemEnd); + } + } else { + MoveNonOverlappingRegion(aDest, aSrc, aCount, aElemSize); + } + } + + static void MoveNonOverlappingRegion(void* aDest, void* aSrc, size_t aCount, + size_t aElemSize) + { + ElemType* destElem = static_cast(aDest); + ElemType* srcElem = static_cast(aSrc); + ElemType* destElemEnd = destElem + aCount; + + + + + while (destElem != destElemEnd) { + traits::Construct(destElem, mozilla::Move(*srcElem)); + traits::Destruct(srcElem); + ++destElem; + ++srcElem; + } + } +}; + + + + +template +struct nsTArray_CopyChooser +{ + typedef nsTArray_CopyWithMemutils Type; +}; +# 725 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" +template +struct nsTArray_CopyChooser> +{ + typedef nsTArray_CopyWithConstructors> Type; +}; + +template<> struct nsTArray_CopyChooser { typedef nsTArray_CopyWithConstructors Type; }; +template<> struct nsTArray_CopyChooser { typedef nsTArray_CopyWithConstructors Type; }; +template<> struct nsTArray_CopyChooser { typedef nsTArray_CopyWithConstructors Type; }; +template<> struct nsTArray_CopyChooser { typedef nsTArray_CopyWithConstructors Type; }; +template<> struct nsTArray_CopyChooser { typedef nsTArray_CopyWithConstructors Type; }; +template<> struct nsTArray_CopyChooser { typedef nsTArray_CopyWithConstructors Type; }; +template<> struct nsTArray_CopyChooser { typedef nsTArray_CopyWithConstructors Type; };; +template<> struct nsTArray_CopyChooser { typedef nsTArray_CopyWithConstructors Type; }; +template<> struct nsTArray_CopyChooser { typedef nsTArray_CopyWithConstructors Type; };; +template<> struct nsTArray_CopyChooser { typedef nsTArray_CopyWithConstructors Type; }; +template<> struct nsTArray_CopyChooser { typedef nsTArray_CopyWithConstructors Type; }; +template<> struct nsTArray_CopyChooser { typedef nsTArray_CopyWithConstructors Type; }; + +template +struct nsTArray_CopyChooser> +{ + typedef nsTArray_CopyWithConstructors> Type; +}; + + + + + + + +template +struct nsTArray_TypedBase : public nsTArray_SafeElementAtHelper +{ +}; +# 772 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" +template +struct nsTArray_TypedBase, Derived> + : public nsTArray_SafeElementAtHelper, Derived> +{ + operator const nsTArray&() + { + static_assert(sizeof(E) == sizeof(JS::Heap), + "JS::Heap must be binary compatible with E."); + Derived* self = static_cast(this); + return *reinterpret_cast *>(self); + } + + operator const FallibleTArray&() + { + Derived* self = static_cast(this); + return *reinterpret_cast *>(self); + } +}; + +namespace detail { + +template +struct ItemComparatorEq +{ + const Item& mItem; + const Comparator& mComp; + ItemComparatorEq(const Item& aItem, const Comparator& aComp) + : mItem(aItem) + , mComp(aComp) + {} + template + int operator()(const T& aElement) const { + if (mComp.Equals(aElement, mItem)) { + return 0; + } + + return mComp.LessThan(aElement, mItem) ? 1 : -1; + } +}; + +template +struct ItemComparatorFirstElementGT +{ + const Item& mItem; + const Comparator& mComp; + ItemComparatorFirstElementGT(const Item& aItem, const Comparator& aComp) + : mItem(aItem) + , mComp(aComp) + {} + template + int operator()(const T& aElement) const { + if (mComp.LessThan(aElement, mItem) || + mComp.Equals(aElement, mItem)) { + return 1; + } else { + return -1; + } + } +}; + +} +# 846 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" +template +class nsTArray_Impl + : public nsTArray_base::Type> + , public nsTArray_TypedBase> +{ +private: + typedef nsTArrayFallibleAllocator FallibleAlloc; + typedef nsTArrayInfallibleAllocator InfallibleAlloc; + +public: + typedef typename nsTArray_CopyChooser::Type copy_type; + typedef nsTArray_base base_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::index_type index_type; + typedef E elem_type; + typedef nsTArray_Impl self_type; + typedef nsTArrayElementTraits elem_traits; + typedef nsTArray_SafeElementAtHelper safeelementat_helper_type; + typedef mozilla::ArrayIterator> iterator; + typedef mozilla::ArrayIterator> const_iterator; + typedef mozilla::ReverseIterator reverse_iterator; + typedef mozilla::ReverseIterator const_reverse_iterator; + + using safeelementat_helper_type::SafeElementAt; + using base_type::EmptyHdr; + + + + static const index_type NoIndex = index_type(-1); + + using base_type::Length; + + + + + + ~nsTArray_Impl() { Clear(); } + + + + + + nsTArray_Impl() {} + + + explicit nsTArray_Impl(size_type aCapacity) { SetCapacity(aCapacity); } + + + + template + explicit nsTArray_Impl(nsTArray_Impl&& aOther) + { + SwapElements(aOther); + } +# 916 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" + explicit nsTArray_Impl(const self_type& aOther) { AppendElements(aOther); } + + explicit nsTArray_Impl(std::initializer_list aIL) { AppendElements(aIL.begin(), aIL.size()); } + + + template + operator const nsTArray_Impl&() const + { + return *reinterpret_cast*>(this); + } + + operator const nsTArray&() const + { + return *reinterpret_cast*>(this); + } + operator const FallibleTArray&() const + { + return *reinterpret_cast*>(this); + } + + + + + self_type& operator=(const self_type& aOther) + { + if (this != &aOther) { + ReplaceElementsAt(0, Length(), aOther.Elements(), aOther.Length()); + } + return *this; + } + + + + + self_type& operator=(self_type&& aOther) + { + if (this != &aOther) { + Clear(); + SwapElements(aOther); + } + return *this; + } + + + + template + bool operator==(const nsTArray_Impl& aOther) const + { + size_type len = Length(); + if (len != aOther.Length()) { + return false; + } + + + for (index_type i = 0; i < len; ++i) { + if (!(operator[](i) == aOther[i])) { + return false; + } + } + + return true; + } + + + + bool operator!=(const self_type& aOther) const { return !operator==(aOther); } + + template + self_type& operator=(const nsTArray_Impl& aOther) + { + ReplaceElementsAt(0, Length(), aOther.Elements(), aOther.Length()); + return *this; + } + + template + self_type& operator=(nsTArray_Impl&& aOther) + { + Clear(); + SwapElements(aOther); + return *this; + } + + + + + + size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const + { + if (this->UsesAutoArrayBuffer() || Hdr() == EmptyHdr()) { + return 0; + } + return aMallocSizeOf(this->Hdr()); + } + + + + + + size_t ShallowSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const + { + return aMallocSizeOf(this) + ShallowSizeOfExcludingThis(aMallocSizeOf); + } +# 1026 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" + elem_type* Elements() { return reinterpret_cast(Hdr() + 1); } + + + + + const elem_type* Elements() const + { + return reinterpret_cast(Hdr() + 1); + } + + + + + + elem_type& ElementAt(index_type aIndex) + { + if ((__builtin_expect(!!(aIndex >= Length()), 0))) { + InvalidArrayIndex_CRASH(aIndex, Length()); + } + return Elements()[aIndex]; + } + + + + + + const elem_type& ElementAt(index_type aIndex) const + { + if ((__builtin_expect(!!(aIndex >= Length()), 0))) { + InvalidArrayIndex_CRASH(aIndex, Length()); + } + return Elements()[aIndex]; + } + + + + + + + elem_type& SafeElementAt(index_type aIndex, elem_type& aDef) + { + return aIndex < Length() ? Elements()[aIndex] : aDef; + } + + + + + + + const elem_type& SafeElementAt(index_type aIndex, const elem_type& aDef) const + { + return aIndex < Length() ? Elements()[aIndex] : aDef; + } + + + elem_type& operator[](index_type aIndex) { return ElementAt(aIndex); } + + + const elem_type& operator[](index_type aIndex) const { return ElementAt(aIndex); } + + + elem_type& LastElement() { return ElementAt(Length() - 1); } + + + const elem_type& LastElement() const { return ElementAt(Length() - 1); } + + + elem_type& SafeLastElement(elem_type& aDef) + { + return SafeElementAt(Length() - 1, aDef); + } + + + const elem_type& SafeLastElement(const elem_type& aDef) const + { + return SafeElementAt(Length() - 1, aDef); + } + + + iterator begin() { return iterator(*this, 0); } + const_iterator begin() const { return const_iterator(*this, 0); } + const_iterator cbegin() const { return begin(); } + iterator end() { return iterator(*this, Length()); } + const_iterator end() const { return const_iterator(*this, Length()); } + const_iterator cend() const { return end(); } + + + reverse_iterator rbegin() { return reverse_iterator(end()); } + const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } + const_reverse_iterator crbegin() const { return rbegin(); } + reverse_iterator rend() { return reverse_iterator(begin()); } + const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } + const_reverse_iterator crend() const { return rend(); } + + + + operator mozilla::Span() + { + return mozilla::Span(Elements(), Length()); + } + + operator mozilla::Span() const + { + return mozilla::Span(Elements(), Length()); + } +# 1141 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" + template + bool Contains(const Item& aItem, const Comparator& aComp) const + { + return IndexOf(aItem, 0, aComp) != NoIndex; + } + + + + + + + template + bool Contains(const Item& aItem) const + { + return IndexOf(aItem) != NoIndex; + } + + + + + + + + template + index_type IndexOf(const Item& aItem, index_type aStart, + const Comparator& aComp) const + { + const elem_type* iter = Elements() + aStart; + const elem_type* iend = Elements() + Length(); + for (; iter != iend; ++iter) { + if (aComp.Equals(*iter, aItem)) { + return index_type(iter - Elements()); + } + } + return NoIndex; + } + + + + + + + + template + index_type IndexOf(const Item& aItem, index_type aStart = 0) const + { + return IndexOf(aItem, aStart, nsDefaultComparator()); + } +# 1197 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" + template + index_type LastIndexOf(const Item& aItem, index_type aStart, + const Comparator& aComp) const + { + size_type endOffset = aStart >= Length() ? Length() : aStart + 1; + const elem_type* iend = Elements() - 1; + const elem_type* iter = iend + endOffset; + for (; iter != iend; --iter) { + if (aComp.Equals(*iter, aItem)) { + return index_type(iter - Elements()); + } + } + return NoIndex; + } +# 1219 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" + template + index_type LastIndexOf(const Item& aItem, + index_type aStart = NoIndex) const + { + return LastIndexOf(aItem, aStart, nsDefaultComparator()); + } +# 1233 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" + template + index_type BinaryIndexOf(const Item& aItem, const Comparator& aComp) const + { + using mozilla::BinarySearchIf; + typedef ::detail::ItemComparatorEq Cmp; + + size_t index; + bool found = BinarySearchIf(*this, 0, Length(), Cmp(aItem, aComp), &index); + return found ? index : NoIndex; + } + + + + + + + template + index_type BinaryIndexOf(const Item& aItem) const + { + return BinaryIndexOf(aItem, nsDefaultComparator()); + } + + + + + + template + typename ActualAlloc::ResultType Assign( + const nsTArray_Impl& aOther) + { + return ActualAlloc::ConvertBoolToResultType( + !!ReplaceElementsAt(0, Length(), + aOther.Elements(), aOther.Length())); + } + + template + __attribute__ ((warn_unused_result)) + bool Assign(const nsTArray_Impl& aOther, + const mozilla::fallible_t&) + { + return Assign(aOther); + } + + template + void Assign(nsTArray_Impl&& aOther) + { + Clear(); + SwapElements(aOther); + } + + + + + + + void ClearAndRetainStorage() + { + if (base_type::mHdr == EmptyHdr()) { + return; + } + + DestructRange(0, Length()); + base_type::mHdr->mLength = 0; + } +# 1306 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" + void SetLengthAndRetainStorage(size_type aNewLen) + { + do { } while (0); + size_type oldLen = Length(); + if (aNewLen > oldLen) { + InsertElementsAt(oldLen, aNewLen - oldLen); + return; + } + if (aNewLen < oldLen) { + DestructRange(aNewLen, oldLen - aNewLen); + base_type::mHdr->mLength = aNewLen; + } + } +# 1330 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" +protected: + template + elem_type* ReplaceElementsAt(index_type aStart, size_type aCount, + const Item* aArray, size_type aArrayLen); + +public: + + template + __attribute__ ((warn_unused_result)) + elem_type* ReplaceElementsAt(index_type aStart, size_type aCount, + const Item* aArray, size_type aArrayLen, + const mozilla::fallible_t&) + { + return ReplaceElementsAt(aStart, aCount, + aArray, aArrayLen); + } + + +protected: + template + elem_type* ReplaceElementsAt(index_type aStart, size_type aCount, + const nsTArray& aArray) + { + return ReplaceElementsAt( + aStart, aCount, aArray.Elements(), aArray.Length()); + } + + template + elem_type* ReplaceElementsAt(index_type aStart, + size_type aCount, + mozilla::Span aSpan) + { + return ReplaceElementsAt( + aStart, aCount, aSpan.Elements(), aSpan.Length()); + } + +public: + + template + __attribute__ ((warn_unused_result)) + elem_type* ReplaceElementsAt(index_type aStart, size_type aCount, + const nsTArray& aArray, + const mozilla::fallible_t&) + { + return ReplaceElementsAt(aStart, aCount, aArray); + } + + template + __attribute__ ((warn_unused_result)) elem_type* ReplaceElementsAt(index_type aStart, + size_type aCount, + mozilla::Span aSpan, + const mozilla::fallible_t&) + { + return ReplaceElementsAt(aStart, aCount, aSpan); + } + + +protected: + template + elem_type* ReplaceElementsAt(index_type aStart, size_type aCount, + const Item& aItem) + { + return ReplaceElementsAt(aStart, aCount, &aItem, 1); + } +public: + + template + __attribute__ ((warn_unused_result)) + elem_type* ReplaceElementsAt(index_type aStart, size_type aCount, + const Item& aItem, const mozilla::fallible_t&) + { + return ReplaceElementsAt(aStart, aCount, aItem); + } + + + template + elem_type* ReplaceElementAt(index_type aIndex, const Item& aItem) + { + return ReplaceElementsAt(aIndex, 1, &aItem, 1); + } + + +protected: + template + elem_type* InsertElementsAt(index_type aIndex, const Item* aArray, + size_type aArrayLen) + { + return ReplaceElementsAt(aIndex, 0, aArray, aArrayLen); + } +public: + + template + __attribute__ ((warn_unused_result)) + elem_type* InsertElementsAt(index_type aIndex, const Item* aArray, + size_type aArrayLen, const mozilla::fallible_t&) + { + return InsertElementsAt(aIndex, aArray, aArrayLen); + } + + +protected: + template + elem_type* InsertElementsAt(index_type aIndex, + const nsTArray_Impl& aArray) + { + return ReplaceElementsAt( + aIndex, 0, aArray.Elements(), aArray.Length()); + } + + template + elem_type* InsertElementsAt(index_type aIndex, + mozilla::Span aSpan) + { + return ReplaceElementsAt( + aIndex, 0, aSpan.Elements(), aSpan.Length()); + } + +public: + + template + __attribute__ ((warn_unused_result)) + elem_type* InsertElementsAt(index_type aIndex, + const nsTArray_Impl& aArray, + const mozilla::fallible_t&) + { + return InsertElementsAt(aIndex, aArray); + } + + template + __attribute__ ((warn_unused_result)) elem_type* InsertElementsAt(index_type aIndex, + mozilla::Span aSpan, + const mozilla::fallible_t&) + { + return InsertElementsAt(aIndex, aSpan); + } + + + + +protected: + template + elem_type* InsertElementAt(index_type aIndex); + +public: + + __attribute__ ((warn_unused_result)) + elem_type* InsertElementAt(index_type aIndex, const mozilla::fallible_t&) + { + return InsertElementAt(aIndex); + } + + +protected: + template + elem_type* InsertElementAt(index_type aIndex, Item&& aItem); + +public: + + template + __attribute__ ((warn_unused_result)) + elem_type* InsertElementAt(index_type aIndex, Item&& aItem, + const mozilla::fallible_t&) + { + return InsertElementAt(aIndex, + mozilla::Forward(aItem)); + } +# 1507 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" + elem_type* ReconstructElementAt(index_type aIndex) + { + elem_type* elem = &ElementAt(aIndex); + elem_traits::Destruct(elem); + elem_traits::Construct(elem); + return elem; + } +# 1530 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" + template + index_type IndexOfFirstElementGt(const Item& aItem, + const Comparator& aComp) const + { + using mozilla::BinarySearchIf; + typedef ::detail::ItemComparatorFirstElementGT Cmp; + + size_t index; + BinarySearchIf(*this, 0, Length(), Cmp(aItem, aComp), &index); + return index; + } + + + template + index_type + IndexOfFirstElementGt(const Item& aItem) const + { + return IndexOfFirstElementGt(aItem, nsDefaultComparator()); + } + + + + +protected: + template + elem_type* InsertElementSorted(Item&& aItem, const Comparator& aComp) + { + index_type index = IndexOfFirstElementGt(aItem, aComp); + return InsertElementAt( + index, mozilla::Forward(aItem)); + } +public: + + template + __attribute__ ((warn_unused_result)) + elem_type* InsertElementSorted(Item&& aItem, const Comparator& aComp, + const mozilla::fallible_t&) + { + return InsertElementSorted( + mozilla::Forward(aItem), aComp); + } + + +protected: + template + elem_type* InsertElementSorted(Item&& aItem) + { + nsDefaultComparator comp; + return InsertElementSorted( + mozilla::Forward(aItem), comp); + } +public: + + template + __attribute__ ((warn_unused_result)) + elem_type* InsertElementSorted(Item&& aItem, const mozilla::fallible_t&) + { + return InsertElementSorted( + mozilla::Forward(aItem)); + } + + + + + + +protected: + template + elem_type* AppendElements(const Item* aArray, size_type aArrayLen); + + template + elem_type* AppendElements(mozilla::Span aSpan) + { + return AppendElements(aSpan.Elements(), + aSpan.Length()); + } + + template + elem_type* AppendElements(const mozilla::Array& aArray) + { + return AppendElements(&aArray[0], Length); + } + +public: + + template + + elem_type* AppendElements(const Item* aArray, size_type aArrayLen, + const mozilla::fallible_t&) + { + return AppendElements(aArray, aArrayLen); + } + + template + + elem_type* AppendElements(mozilla::Span aSpan, + const mozilla::fallible_t&) + { + return AppendElements(aSpan.Elements(), + aSpan.Length()); + } + + +protected: + template + elem_type* AppendElements(const nsTArray_Impl& aArray) + { + return AppendElements(aArray.Elements(), aArray.Length()); + } +public: + + template + + elem_type* AppendElements(const nsTArray_Impl& aArray, + const mozilla::fallible_t&) + { + return AppendElements(aArray); + } + + + +protected: + template + elem_type* AppendElements(nsTArray_Impl&& aArray); + +public: + + template + + elem_type* AppendElements(nsTArray_Impl&& aArray, + const mozilla::fallible_t&) + { + return AppendElements(mozilla::Move(aArray)); + } + + +protected: + template + elem_type* AppendElement(Item&& aItem); + +public: + + template + + elem_type* AppendElement(Item&& aItem, + const mozilla::fallible_t&) + { + return AppendElement(mozilla::Forward(aItem)); + } + + + + +protected: + template + elem_type* AppendElements(size_type aCount) { + if (!ActualAlloc::Successful(this->template EnsureCapacity( + Length() + aCount, sizeof(elem_type)))) { + return nullptr; + } + elem_type* elems = Elements() + Length(); + size_type i; + for (i = 0; i < aCount; ++i) { + elem_traits::Construct(elems + i); + } + this->IncrementLength(aCount); + return elems; + } +public: + + + elem_type* AppendElements(size_type aCount, + const mozilla::fallible_t&) + { + return AppendElements(aCount); + } + + + + +protected: + template + elem_type* AppendElement() + { + return AppendElements(1); + } +public: + + + elem_type* AppendElement(const mozilla::fallible_t&) + { + return AppendElement(); + } + + + + + void RemoveElementsAt(index_type aStart, size_type aCount); + + + void RemoveElementAt(index_type aIndex) { RemoveElementsAt(aIndex, 1); } + + + void Clear() { RemoveElementsAt(0, Length()); } + + + + + + + template + void RemoveElementsBy(Predicate aPredicate); + + + + + + + template + bool RemoveElement(const Item& aItem, const Comparator& aComp) + { + index_type i = IndexOf(aItem, 0, aComp); + if (i == NoIndex) { + return false; + } + + RemoveElementAt(i); + return true; + } + + + + template + bool RemoveElement(const Item& aItem) + { + return RemoveElement(aItem, nsDefaultComparator()); + } + + + + + + + + template + bool RemoveElementSorted(const Item& aItem, const Comparator& aComp) + { + index_type index = IndexOfFirstElementGt(aItem, aComp); + if (index > 0 && aComp.Equals(ElementAt(index - 1), aItem)) { + RemoveElementAt(index - 1); + return true; + } + return false; + } + + + template + bool RemoveElementSorted(const Item& aItem) + { + return RemoveElementSorted(aItem, nsDefaultComparator()); + } + + + + template + typename Alloc::ResultType SwapElements(nsTArray_Impl& aOther) + { + return Alloc::Result(this->template SwapArrayElements( + aOther, sizeof(elem_type), mozilla::AlignmentFinder::alignment)); + } +# 1811 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" +protected: + template + typename ActualAlloc::ResultType SetCapacity(size_type aCapacity) + { + return ActualAlloc::Result(this->template EnsureCapacity( + aCapacity, sizeof(elem_type))); + } +public: + + __attribute__ ((warn_unused_result)) + bool SetCapacity(size_type aCapacity, const mozilla::fallible_t&) + { + return SetCapacity(aCapacity); + } +# 1834 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" +protected: + template + typename ActualAlloc::ResultType SetLength(size_type aNewLen) + { + size_type oldLen = Length(); + if (aNewLen > oldLen) { + return ActualAlloc::ConvertBoolToResultType( + InsertElementsAt(oldLen, aNewLen - oldLen) != nullptr); + } + + TruncateLength(aNewLen); + return ActualAlloc::ConvertBoolToResultType(true); + } +public: + + __attribute__ ((warn_unused_result)) + bool SetLength(size_type aNewLen, const mozilla::fallible_t&) + { + return SetLength(aNewLen); + } + + + + + + + + void TruncateLength(size_type aNewLen) + { + size_type oldLen = Length(); + do { } while (0); + + RemoveElementsAt(aNewLen, oldLen - aNewLen); + } + + + + + + + +protected: + template + typename ActualAlloc::ResultType EnsureLengthAtLeast(size_type aMinLen) + { + size_type oldLen = Length(); + if (aMinLen > oldLen) { + return ActualAlloc::ConvertBoolToResultType( + !!InsertElementsAt(oldLen, aMinLen - oldLen)); + } + return ActualAlloc::ConvertBoolToResultType(true); + } +public: + + __attribute__ ((warn_unused_result)) + bool EnsureLengthAtLeast(size_type aMinLen, const mozilla::fallible_t&) + { + return EnsureLengthAtLeast(aMinLen); + } + + + + + + +protected: + template + elem_type* InsertElementsAt(index_type aIndex, size_type aCount) + { + if (!base_type::template InsertSlotsAt(aIndex, aCount, + sizeof(elem_type), + mozilla::AlignmentFinder::alignment)) { + return nullptr; + } + + + elem_type* iter = Elements() + aIndex; + elem_type* iend = iter + aCount; + for (; iter != iend; ++iter) { + elem_traits::Construct(iter); + } + + return Elements() + aIndex; + } +public: + + __attribute__ ((warn_unused_result)) + elem_type* InsertElementsAt(index_type aIndex, size_type aCount, + const mozilla::fallible_t&) + { + return InsertElementsAt(aIndex, aCount); + } +# 1934 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" +protected: + template + elem_type* InsertElementsAt(index_type aIndex, size_type aCount, + const Item& aItem); + +public: + + template + __attribute__ ((warn_unused_result)) + elem_type* InsertElementsAt(index_type aIndex, size_type aCount, + const Item& aItem, const mozilla::fallible_t&) + { + return InsertElementsAt(aIndex, aCount, aItem); + } + + + void Compact() + { + ShrinkCapacity(sizeof(elem_type), mozilla::AlignmentFinder::alignment); + } +# 1962 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" + template + static int Compare(const void* aE1, const void* aE2, void* aData) + { + const Comparator* c = reinterpret_cast(aData); + const elem_type* a = static_cast(aE1); + const elem_type* b = static_cast(aE2); + return c->LessThan(*a, *b) ? -1 : (c->Equals(*a, *b) ? 0 : 1); + } + + + + + template + void Sort(const Comparator& aComp) + { + NS_QuickSort(Elements(), Length(), sizeof(elem_type), + Compare, const_cast(&aComp)); + } + + + + void Sort() { Sort(nsDefaultComparator()); } + + + void Reverse() + { + elem_type* elements = Elements(); + const size_type len = Length(); + for (index_type i = 0, iend = len / 2; i < iend; ++i) { + mozilla::Swap(elements[i], elements[len - i - 1]); + } + } + +protected: + using base_type::Hdr; + using base_type::ShrinkCapacity; + + + + + void DestructRange(index_type aStart, size_type aCount) + { + elem_type* iter = Elements() + aStart; + elem_type *iend = iter + aCount; + for (; iter != iend; ++iter) { + elem_traits::Destruct(iter); + } + } + + + + + + template + void AssignRange(index_type aStart, size_type aCount, const Item* aValues) + { + AssignRangeAlgorithm::value, + mozilla::IsSame::value> + ::implementation(Elements(), aStart, aCount, aValues); + } +}; + +template +template +auto +nsTArray_Impl::ReplaceElementsAt(index_type aStart, size_type aCount, + const Item* aArray, size_type aArrayLen) -> elem_type* +{ + if ((__builtin_expect(!!(aStart > Length()), 0))) { + InvalidArrayIndex_CRASH(aStart, Length()); + } + + + if (!ActualAlloc::Successful(this->template EnsureCapacity( + Length() + aArrayLen - aCount, sizeof(elem_type)))) { + return nullptr; + } + DestructRange(aStart, aCount); + this->template ShiftData(aStart, aCount, aArrayLen, + sizeof(elem_type), + mozilla::AlignmentFinder::alignment); + AssignRange(aStart, aArrayLen, aArray); + return Elements() + aStart; +} + +template +void +nsTArray_Impl::RemoveElementsAt(index_type aStart, size_type aCount) +{ + do { } while (0); + do { } while (0); + + do { } while (0); + DestructRange(aStart, aCount); + this->template ShiftData(aStart, aCount, 0, + sizeof(elem_type), + mozilla::AlignmentFinder::alignment); +} + +template +template +void +nsTArray_Impl::RemoveElementsBy(Predicate aPredicate) +{ + if (base_type::mHdr == EmptyHdr()) { + return; + } + + index_type j = 0; + index_type len = Length(); + for (index_type i = 0; i < len; ++i) { + if (aPredicate(Elements()[i])) { + elem_traits::Destruct(Elements() + i); + } else { + if (j < i) { + copy_type::MoveNonOverlappingRegion(Elements() + j, Elements() + i, + 1, sizeof(elem_type)); + } + ++j; + } + } + base_type::mHdr->mLength = j; +} + +template +template +auto +nsTArray_Impl::InsertElementsAt(index_type aIndex, size_type aCount, + const Item& aItem) -> elem_type* +{ + if (!base_type::template InsertSlotsAt(aIndex, aCount, + sizeof(elem_type), + mozilla::AlignmentFinder::alignment)) { + return nullptr; + } + + + elem_type* iter = Elements() + aIndex; + elem_type* iend = iter + aCount; + for (; iter != iend; ++iter) { + elem_traits::Construct(iter, aItem); + } + + return Elements() + aIndex; +} + +template +template +auto +nsTArray_Impl::InsertElementAt(index_type aIndex) -> elem_type* +{ + if ((__builtin_expect(!!(aIndex > Length()), 0))) { + InvalidArrayIndex_CRASH(aIndex, Length()); + } + + if (!ActualAlloc::Successful(this->template EnsureCapacity( + Length() + 1, sizeof(elem_type)))) { + return nullptr; + } + this->template ShiftData(aIndex, 0, 1, sizeof(elem_type), + mozilla::AlignmentFinder::alignment); + elem_type* elem = Elements() + aIndex; + elem_traits::Construct(elem); + return elem; +} + +template +template +auto +nsTArray_Impl::InsertElementAt(index_type aIndex, Item&& aItem) -> elem_type* +{ + if ((__builtin_expect(!!(aIndex > Length()), 0))) { + InvalidArrayIndex_CRASH(aIndex, Length()); + } + + if (!ActualAlloc::Successful(this->template EnsureCapacity( + Length() + 1, sizeof(elem_type)))) { + return nullptr; + } + this->template ShiftData(aIndex, 0, 1, sizeof(elem_type), + mozilla::AlignmentFinder::alignment); + elem_type* elem = Elements() + aIndex; + elem_traits::Construct(elem, mozilla::Forward(aItem)); + return elem; +} + +template +template +auto +nsTArray_Impl::AppendElements(const Item* aArray, size_type aArrayLen) -> elem_type* +{ + if (!ActualAlloc::Successful(this->template EnsureCapacity( + Length() + aArrayLen, sizeof(elem_type)))) { + return nullptr; + } + index_type len = Length(); + AssignRange(len, aArrayLen, aArray); + this->IncrementLength(aArrayLen); + return Elements() + len; +} + +template +template +auto +nsTArray_Impl::AppendElements(nsTArray_Impl&& aArray) -> elem_type* +{ + do { } while (0); + if (Length() == 0) { + SwapElements(aArray); + return Elements(); + } + + index_type len = Length(); + index_type otherLen = aArray.Length(); + if (!Alloc::Successful(this->template EnsureCapacity( + len + otherLen, sizeof(elem_type)))) { + return nullptr; + } + copy_type::MoveNonOverlappingRegion(Elements() + len, aArray.Elements(), otherLen, + sizeof(elem_type)); + this->IncrementLength(otherLen); + aArray.template ShiftData(0, otherLen, 0, sizeof(elem_type), + mozilla::AlignmentFinder::alignment); + return Elements() + len; +} + +template +template +auto +nsTArray_Impl::AppendElement(Item&& aItem) -> elem_type* +{ + if (!ActualAlloc::Successful(this->template EnsureCapacity( + Length() + 1, sizeof(elem_type)))) { + return nullptr; + } + elem_type* elem = Elements() + Length(); + elem_traits::Construct(elem, mozilla::Forward(aItem)); + this->IncrementLength(1); + return elem; +} + +template +inline void +ImplCycleCollectionUnlink(nsTArray_Impl& aField) +{ + aField.Clear(); +} + +template +inline void +ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback, + nsTArray_Impl& aField, + const char* aName, + uint32_t aFlags = 0) +{ + aFlags |= CycleCollectionEdgeNameArrayFlag; + size_t length = aField.Length(); + for (size_t i = 0; i < length; ++i) { + ImplCycleCollectionTraverse(aCallback, aField[i], aName, aFlags); + } +} + + + + + +template +class nsTArray : public nsTArray_Impl +{ +public: + typedef nsTArray_Impl base_type; + typedef nsTArray self_type; + typedef typename base_type::size_type size_type; + + nsTArray() {} + explicit nsTArray(size_type aCapacity) : base_type(aCapacity) {} + explicit nsTArray(const nsTArray& aOther) : base_type(aOther) {} + nsTArray(nsTArray&& aOther) : base_type(mozilla::Move(aOther)) {} + nsTArray(std::initializer_list aIL) : base_type(aIL) {} + + template + explicit nsTArray(const nsTArray_Impl& aOther) + : base_type(aOther) + { + } + template + nsTArray(nsTArray_Impl&& aOther) + : base_type(mozilla::Move(aOther)) + { + } + + self_type& operator=(const self_type& aOther) + { + base_type::operator=(aOther); + return *this; + } + template + self_type& operator=(const nsTArray_Impl& aOther) + { + base_type::operator=(aOther); + return *this; + } + self_type& operator=(self_type&& aOther) + { + base_type::operator=(mozilla::Move(aOther)); + return *this; + } + template + self_type& operator=(nsTArray_Impl&& aOther) + { + base_type::operator=(mozilla::Move(aOther)); + return *this; + } + + using base_type::AppendElement; + using base_type::AppendElements; + using base_type::EnsureLengthAtLeast; + using base_type::InsertElementAt; + using base_type::InsertElementsAt; + using base_type::InsertElementSorted; + using base_type::ReplaceElementsAt; + using base_type::SetCapacity; + using base_type::SetLength; +}; + + + + +template +class FallibleTArray : public nsTArray_Impl +{ +public: + typedef nsTArray_Impl base_type; + typedef FallibleTArray self_type; + typedef typename base_type::size_type size_type; + + FallibleTArray() {} + explicit FallibleTArray(size_type aCapacity) : base_type(aCapacity) {} + explicit FallibleTArray(const FallibleTArray& aOther) : base_type(aOther) {} + FallibleTArray(FallibleTArray&& aOther) + : base_type(mozilla::Move(aOther)) + { + } + + template + explicit FallibleTArray(const nsTArray_Impl& aOther) + : base_type(aOther) + { + } + template + explicit FallibleTArray(nsTArray_Impl&& aOther) + : base_type(mozilla::Move(aOther)) + { + } + + self_type& operator=(const self_type& aOther) + { + base_type::operator=(aOther); + return *this; + } + template + self_type& operator=(const nsTArray_Impl& aOther) + { + base_type::operator=(aOther); + return *this; + } + self_type& operator=(self_type&& aOther) + { + base_type::operator=(mozilla::Move(aOther)); + return *this; + } + template + self_type& operator=(nsTArray_Impl&& aOther) + { + base_type::operator=(mozilla::Move(aOther)); + return *this; + } +}; + + + + + +template +class AutoTArray : public nsTArray +{ + static_assert(N != 0, "AutoTArray should be specialized"); +public: + typedef AutoTArray self_type; + typedef nsTArray base_type; + typedef typename base_type::Header Header; + typedef typename base_type::elem_type elem_type; + + AutoTArray() + { + Init(); + } + + AutoTArray(const self_type& aOther) + { + Init(); + this->AppendElements(aOther); + } + + explicit AutoTArray(const base_type& aOther) + { + Init(); + this->AppendElements(aOther); + } + + explicit AutoTArray(base_type&& aOther) + { + Init(); + this->SwapElements(aOther); + } + + template + explicit AutoTArray(nsTArray_Impl&& aOther) + { + Init(); + this->SwapElements(aOther); + } + + AutoTArray(std::initializer_list aIL) + { + Init(); + this->AppendElements(aIL.begin(), aIL.size()); + } + + self_type& operator=(const self_type& aOther) + { + base_type::operator=(aOther); + return *this; + } + + template + self_type& operator=(const nsTArray_Impl& aOther) + { + base_type::operator=(aOther); + return *this; + } + +private: + + + template + friend class nsTArray_base; + + void Init() + { + static_assert(mozilla::AlignmentFinder::alignment <= 8, + "can't handle alignments greater than 8, " + "see nsTArray_base::UsesAutoArrayBuffer()"); + + Header** phdr = base_type::PtrToHdr(); + *phdr = reinterpret_cast(&mAutoBuf); + (*phdr)->mLength = 0; + (*phdr)->mCapacity = N; + (*phdr)->mIsAutoArray = 1; + + do { } while (0); + + + } + + + + + + union + { + char mAutoBuf[sizeof(nsTArrayHeader) + N * sizeof(elem_type)]; + + mozilla::AlignedElem<(mozilla::AlignmentFinder
::alignment > mozilla::AlignmentFinder::alignment) ? + mozilla::AlignmentFinder
::alignment : mozilla::AlignmentFinder::alignment> mAlign; + }; +}; +# 2454 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" +template +class AutoTArray : public nsTArray +{ +}; + +template +struct nsTArray_CopyChooser> +{ + typedef nsTArray_CopyWithConstructors> Type; +}; + + +namespace mozilla { + +template +Span +MakeSpan(nsTArray_Impl& aTArray) +{ + return aTArray; +} + +template +Span +MakeSpan(const nsTArray_Impl& aTArray) +{ + return aTArray; +} + +} +# 2497 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" +static_assert(sizeof(AutoTArray) == + sizeof(void*) + sizeof(nsTArrayHeader) + sizeof(uint32_t) * 2, + "AutoTArray shouldn't contain any extra padding, " + "see the comment"); + + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray-inl.h" 1 +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray-inl.h" +template +nsTArray_base::nsTArray_base() + : mHdr(EmptyHdr()) +{ + ; +} + +template +nsTArray_base::~nsTArray_base() +{ + if (mHdr != EmptyHdr() && !UsesAutoArrayBuffer()) { + Alloc::Free(mHdr); + } + ; +} + +template +const nsTArrayHeader* +nsTArray_base::GetAutoArrayBufferUnsafe(size_t aElemAlign) const +{ + + + + const void* autoBuf = + &reinterpret_cast, 1>*>(this)->mAutoBuf; + + + + + static_assert(sizeof(void*) != 4 || + (mozilla::AlignmentFinder >::alignment == 8 && + sizeof(AutoTArray, 1>) == + sizeof(void*) + sizeof(nsTArrayHeader) + + 4 + sizeof(mozilla::AlignedElem<8>)), + "auto array padding wasn't what we expected"); + + + do { } while (0); + + if (sizeof(void*) == 4 && aElemAlign == 8) { + autoBuf = reinterpret_cast(autoBuf) + 4; + } + + return reinterpret_cast(autoBuf); +} + +template +bool +nsTArray_base::UsesAutoArrayBuffer() const +{ + if (!mHdr->mIsAutoArray) { + return false; + } +# 94 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray-inl.h" + static_assert(sizeof(nsTArrayHeader) > 4, + "see comment above"); +# 104 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray-inl.h" + return mHdr == GetAutoArrayBuffer(4) || mHdr == GetAutoArrayBuffer(8); +} + + +bool IsTwiceTheRequiredBytesRepresentableAsUint32(size_t aCapacity, + size_t aElemSize); + +template +template +typename ActualAlloc::ResultTypeProxy +nsTArray_base::EnsureCapacity(size_type aCapacity, + size_type aElemSize) +{ + + if (aCapacity <= mHdr->mCapacity) { + return ActualAlloc::SuccessResult(); + } + + + + + + + if (!IsTwiceTheRequiredBytesRepresentableAsUint32(aCapacity, aElemSize)) { + ActualAlloc::SizeTooBig((size_t)aCapacity * aElemSize); + return ActualAlloc::FailureResult(); + } + + size_t reqSize = sizeof(Header) + aCapacity * aElemSize; + + if (mHdr == EmptyHdr()) { + + Header* header = static_cast(ActualAlloc::Malloc(reqSize)); + if (!header) { + return ActualAlloc::FailureResult(); + } + header->mLength = 0; + header->mCapacity = aCapacity; + header->mIsAutoArray = 0; + mHdr = header; + + return ActualAlloc::SuccessResult(); + } + + + + + + const size_t slowGrowthThreshold = 8 * 1024 * 1024; + + size_t bytesToAlloc; + if (reqSize >= slowGrowthThreshold) { + size_t currSize = sizeof(Header) + Capacity() * aElemSize; + size_t minNewSize = currSize + (currSize >> 3); + bytesToAlloc = reqSize > minNewSize ? reqSize : minNewSize; + + + const size_t MiB = 1 << 20; + bytesToAlloc = MiB * ((bytesToAlloc + MiB - 1) / MiB); + } else { + + bytesToAlloc = mozilla::RoundUpPow2(reqSize); + } + + Header* header; + if (UsesAutoArrayBuffer() || !Copy::allowRealloc) { + + header = static_cast(ActualAlloc::Malloc(bytesToAlloc)); + if (!header) { + return ActualAlloc::FailureResult(); + } + + Copy::MoveNonOverlappingRegionWithHeader(header, mHdr, Length(), aElemSize); + + if (!UsesAutoArrayBuffer()) { + ActualAlloc::Free(mHdr); + } + } else { + + header = static_cast(ActualAlloc::Realloc(mHdr, bytesToAlloc)); + if (!header) { + return ActualAlloc::FailureResult(); + } + } + + + size_t newCapacity = (bytesToAlloc - sizeof(Header)) / aElemSize; + do { } while (0); + header->mCapacity = newCapacity; + + mHdr = header; + + return ActualAlloc::SuccessResult(); +} + + + +template +void +nsTArray_base::ShrinkCapacity(size_type aElemSize, + size_t aElemAlign) +{ + if (mHdr == EmptyHdr() || UsesAutoArrayBuffer()) { + return; + } + + if (mHdr->mLength >= mHdr->mCapacity) { + return; + } + + size_type length = Length(); + + if (IsAutoArray() && GetAutoArrayBuffer(aElemAlign)->mCapacity >= length) { + Header* header = GetAutoArrayBuffer(aElemAlign); + + + header->mLength = length; + Copy::MoveNonOverlappingRegion(header + 1, mHdr + 1, length, aElemSize); + + nsTArrayFallibleAllocator::Free(mHdr); + mHdr = header; + return; + } + + if (length == 0) { + do { } while (0); + nsTArrayFallibleAllocator::Free(mHdr); + mHdr = EmptyHdr(); + return; + } + + size_type size = sizeof(Header) + length * aElemSize; + void* ptr = nsTArrayFallibleAllocator::Realloc(mHdr, size); + if (!ptr) { + return; + } + mHdr = static_cast(ptr); + mHdr->mCapacity = length; +} + +template +template +void +nsTArray_base::ShiftData(index_type aStart, + size_type aOldLen, size_type aNewLen, + size_type aElemSize, size_t aElemAlign) +{ + if (aOldLen == aNewLen) { + return; + } + + + size_type num = mHdr->mLength - (aStart + aOldLen); + + + mHdr->mLength += aNewLen - aOldLen; + if (mHdr->mLength == 0) { + ShrinkCapacity(aElemSize, aElemAlign); + } else { + + if (num == 0) { + return; + } + + aStart *= aElemSize; + aNewLen *= aElemSize; + aOldLen *= aElemSize; + char* baseAddr = reinterpret_cast(mHdr + 1) + aStart; + Copy::MoveOverlappingRegion(baseAddr + aNewLen, baseAddr + aOldLen, num, aElemSize); + } +} + +template +template +bool +nsTArray_base::InsertSlotsAt(index_type aIndex, size_type aCount, + size_type aElemSize, + size_t aElemAlign) +{ + if ((__builtin_expect(!!(aIndex > Length()), 0))) { + InvalidArrayIndex_CRASH(aIndex, Length()); + } + + size_type newLen = Length() + aCount; + + EnsureCapacity(newLen, aElemSize); + + + if (Capacity() < newLen) { + return false; + } + + + + ShiftData(aIndex, 0, aCount, aElemSize, aElemAlign); + + return true; +} +# 311 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray-inl.h" +template +nsTArray_base::IsAutoArrayRestorer::IsAutoArrayRestorer( + nsTArray_base& aArray, + size_t aElemAlign) + : mArray(aArray) + , mElemAlign(aElemAlign) + , mIsAuto(aArray.IsAutoArray()) +{ +} + +template +nsTArray_base::IsAutoArrayRestorer::~IsAutoArrayRestorer() +{ + + if (mIsAuto && mArray.mHdr == mArray.EmptyHdr()) { + + + mArray.mHdr = mArray.GetAutoArrayBufferUnsafe(mElemAlign); + mArray.mHdr->mLength = 0; + } else if (mArray.mHdr != mArray.EmptyHdr()) { + mArray.mHdr->mIsAutoArray = mIsAuto; + } +} + +template +template +typename ActualAlloc::ResultTypeProxy +nsTArray_base::SwapArrayElements(nsTArray_base& aOther, + size_type aElemSize, + size_t aElemAlign) +{ + + + + + + + IsAutoArrayRestorer ourAutoRestorer(*this, aElemAlign); + typename nsTArray_base::IsAutoArrayRestorer + otherAutoRestorer(aOther, aElemAlign); + + + + + if ((!UsesAutoArrayBuffer() || Capacity() < aOther.Length()) && + (!aOther.UsesAutoArrayBuffer() || aOther.Capacity() < Length())) { + + if (!EnsureNotUsingAutoArrayBuffer(aElemSize) || + !aOther.template EnsureNotUsingAutoArrayBuffer(aElemSize)) { + return ActualAlloc::FailureResult(); + } + + Header* temp = mHdr; + mHdr = aOther.mHdr; + aOther.mHdr = temp; + + return ActualAlloc::SuccessResult(); + } +# 382 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray-inl.h" + if (!ActualAlloc::Successful(EnsureCapacity(aOther.Length(), aElemSize)) || + !Allocator::Successful(aOther.template EnsureCapacity(Length(), aElemSize))) { + return ActualAlloc::FailureResult(); + } + + + + do { } while (0); + + + size_type smallerLength = XPCOM_MIN(Length(), aOther.Length()); + size_type largerLength = XPCOM_MAX(Length(), aOther.Length()); + void* smallerElements; + void* largerElements; + if (Length() <= aOther.Length()) { + smallerElements = Hdr() + 1; + largerElements = aOther.Hdr() + 1; + } else { + smallerElements = aOther.Hdr() + 1; + largerElements = Hdr() + 1; + } + + + + + + + AutoTArray, 64> temp; + if (!ActualAlloc::Successful(temp.template EnsureCapacity(smallerLength, + aElemSize))) { + return ActualAlloc::FailureResult(); + } + + Copy::MoveNonOverlappingRegion(temp.Elements(), smallerElements, smallerLength, aElemSize); + Copy::MoveNonOverlappingRegion(smallerElements, largerElements, largerLength, aElemSize); + Copy::MoveNonOverlappingRegion(largerElements, temp.Elements(), smallerLength, aElemSize); + + + do { } while (0); + + + size_type tempLength = Length(); + + + + if (mHdr != EmptyHdr()) { + mHdr->mLength = aOther.Length(); + } + if (aOther.mHdr != EmptyHdr()) { + aOther.mHdr->mLength = tempLength; + } + + return ActualAlloc::SuccessResult(); +} + +template +template +bool +nsTArray_base::EnsureNotUsingAutoArrayBuffer(size_type aElemSize) +{ + if (UsesAutoArrayBuffer()) { + + + + + + if (Length() == 0) { + mHdr = EmptyHdr(); + return true; + } + + size_type size = sizeof(Header) + Length() * aElemSize; + + Header* header = static_cast(ActualAlloc::Malloc(size)); + if (!header) { + return false; + } + + Copy::MoveNonOverlappingRegionWithHeader(header, mHdr, Length(), aElemSize); + header->mCapacity = Length(); + mHdr = header; + } + + return true; +} +# 2504 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleAutoArray.h" 2 + + + + + + +template +class nsStyleAutoArray +{ +public: + + enum WithSingleInitialElement { WITH_SINGLE_INITIAL_ELEMENT }; + explicit nsStyleAutoArray(WithSingleInitialElement) {} + nsStyleAutoArray(const nsStyleAutoArray& aOther) { *this = aOther; } + nsStyleAutoArray& operator=(const nsStyleAutoArray& aOther) { + mFirstElement = aOther.mFirstElement; + mOtherElements = aOther.mOtherElements; + return *this; + } + + bool operator==(const nsStyleAutoArray& aOther) const { + return Length() == aOther.Length() && + mFirstElement == aOther.mFirstElement && + mOtherElements == aOther.mOtherElements; + } + bool operator!=(const nsStyleAutoArray& aOther) const { + return !(*this == aOther); + } + + nsStyleAutoArray& operator=(nsStyleAutoArray&& aOther) { + mFirstElement = aOther.mFirstElement; + mOtherElements.SwapElements(aOther.mOtherElements); + + return *this; + } + + size_t Length() const { + return mOtherElements.Length() + 1; + } + const T& operator[](size_t aIndex) const { + return aIndex == 0 ? mFirstElement : mOtherElements[aIndex - 1]; + } + T& operator[](size_t aIndex) { + return aIndex == 0 ? mFirstElement : mOtherElements[aIndex - 1]; + } + + void EnsureLengthAtLeast(size_t aMinLen) { + if (aMinLen > 0) { + mOtherElements.EnsureLengthAtLeast(aMinLen - 1); + } + } + + void SetLengthNonZero(size_t aNewLen) { + do { } while (0); + mOtherElements.SetLength(aNewLen - 1); + } + + void TruncateLengthNonZero(size_t aNewLen) { + do { } while (0); + do { } while (0); + mOtherElements.TruncateLength(aNewLen - 1); + } + +private: + T mFirstElement; + nsTArray mOtherElements; +}; +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 2 + + +struct RawServoStyleSet; + + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoArcTypeList.h" 1 + + + + + + + + +struct ServoCssRules; +struct RawServoStyleSheet; +struct ServoComputedValues; +struct RawServoDeclarationBlock; +struct RawServoStyleRule; +struct RawServoImportRule; +struct RawServoAnimationValue; +struct RawServoAnimationValueMap; +struct RawServoMediaList; +struct RawServoMediaRule; +struct RawServoNamespaceRule; +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 2 + + +namespace mozilla { + class ServoElementSnapshot; + struct StyleAnimation; +namespace css { +struct URLExtraData; +} +namespace dom { +class Element; +class StyleChildrenIterator; +} +struct AnimationPropertySegment; +struct ComputedTiming; +struct Keyframe; +struct PropertyStyleAnimationValuePair; +using ComputedKeyframeValues = nsTArray; +} + +class nsCSSValue; +struct nsFontFaceRuleContainer; +class nsIDocument; +class nsINode; +class nsPresContext; +struct nsTimingFunction; + +using mozilla::dom::StyleChildrenIterator; +using mozilla::ServoElementSnapshot; + +typedef nsINode RawGeckoNode; +typedef mozilla::dom::Element RawGeckoElement; +typedef nsIDocument RawGeckoDocument; +typedef nsPresContext RawGeckoPresContext; +typedef mozilla::css::URLExtraData RawGeckoURLExtraData; +typedef nsTArray RawGeckoKeyframeList; +typedef nsTArray RawGeckoComputedKeyframeValuesList; +typedef nsTArray RawGeckoAnimationValueList; +typedef nsStyleAutoArray RawGeckoStyleAnimationList; +typedef nsTArray RawGeckoFontFaceRuleList; +typedef mozilla::AnimationPropertySegment RawGeckoAnimationPropertySegment; +typedef mozilla::ComputedTiming RawGeckoComputedTiming; +# 91 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoArcTypeList.h" 1 + + + + + + + + +typedef ServoCssRules const* ServoCssRulesBorrowedOrNull; typedef ServoCssRules const* ServoCssRulesBorrowed; typedef ServoCssRules* ServoCssRulesBorrowedMut; struct ServoCssRulesStrong { ServoCssRules* mPtr; already_AddRefed Consume(); }; +typedef RawServoStyleSheet const* RawServoStyleSheetBorrowedOrNull; typedef RawServoStyleSheet const* RawServoStyleSheetBorrowed; typedef RawServoStyleSheet* RawServoStyleSheetBorrowedMut; struct RawServoStyleSheetStrong { RawServoStyleSheet* mPtr; already_AddRefed Consume(); }; +typedef ServoComputedValues const* ServoComputedValuesBorrowedOrNull; typedef ServoComputedValues const* ServoComputedValuesBorrowed; typedef ServoComputedValues* ServoComputedValuesBorrowedMut; struct ServoComputedValuesStrong { ServoComputedValues* mPtr; already_AddRefed Consume(); }; +typedef RawServoDeclarationBlock const* RawServoDeclarationBlockBorrowedOrNull; typedef RawServoDeclarationBlock const* RawServoDeclarationBlockBorrowed; typedef RawServoDeclarationBlock* RawServoDeclarationBlockBorrowedMut; struct RawServoDeclarationBlockStrong { RawServoDeclarationBlock* mPtr; already_AddRefed Consume(); }; +typedef RawServoStyleRule const* RawServoStyleRuleBorrowedOrNull; typedef RawServoStyleRule const* RawServoStyleRuleBorrowed; typedef RawServoStyleRule* RawServoStyleRuleBorrowedMut; struct RawServoStyleRuleStrong { RawServoStyleRule* mPtr; already_AddRefed Consume(); }; +typedef RawServoImportRule const* RawServoImportRuleBorrowedOrNull; typedef RawServoImportRule const* RawServoImportRuleBorrowed; typedef RawServoImportRule* RawServoImportRuleBorrowedMut; struct RawServoImportRuleStrong { RawServoImportRule* mPtr; already_AddRefed Consume(); }; +typedef RawServoAnimationValue const* RawServoAnimationValueBorrowedOrNull; typedef RawServoAnimationValue const* RawServoAnimationValueBorrowed; typedef RawServoAnimationValue* RawServoAnimationValueBorrowedMut; struct RawServoAnimationValueStrong { RawServoAnimationValue* mPtr; already_AddRefed Consume(); }; +typedef RawServoAnimationValueMap const* RawServoAnimationValueMapBorrowedOrNull; typedef RawServoAnimationValueMap const* RawServoAnimationValueMapBorrowed; typedef RawServoAnimationValueMap* RawServoAnimationValueMapBorrowedMut; struct RawServoAnimationValueMapStrong { RawServoAnimationValueMap* mPtr; already_AddRefed Consume(); }; +typedef RawServoMediaList const* RawServoMediaListBorrowedOrNull; typedef RawServoMediaList const* RawServoMediaListBorrowed; typedef RawServoMediaList* RawServoMediaListBorrowedMut; struct RawServoMediaListStrong { RawServoMediaList* mPtr; already_AddRefed Consume(); }; +typedef RawServoMediaRule const* RawServoMediaRuleBorrowedOrNull; typedef RawServoMediaRule const* RawServoMediaRuleBorrowed; typedef RawServoMediaRule* RawServoMediaRuleBorrowedMut; struct RawServoMediaRuleStrong { RawServoMediaRule* mPtr; already_AddRefed Consume(); }; +typedef RawServoNamespaceRule const* RawServoNamespaceRuleBorrowedOrNull; typedef RawServoNamespaceRule const* RawServoNamespaceRuleBorrowed; typedef RawServoNamespaceRule* RawServoNamespaceRuleBorrowedMut; struct RawServoNamespaceRuleStrong { RawServoNamespaceRule* mPtr; already_AddRefed Consume(); }; +# 92 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 2 +# 106 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" +typedef RawServoDeclarationBlockStrong const* RawServoDeclarationBlockStrongBorrowedOrNull; + +typedef RawServoStyleSet* RawServoStyleSetOwned; typedef RawServoStyleSet const* RawServoStyleSetBorrowed; typedef RawServoStyleSet* RawServoStyleSetBorrowedMut; +typedef StyleChildrenIterator* StyleChildrenIteratorOwnedOrNull; typedef StyleChildrenIterator const* StyleChildrenIteratorBorrowedOrNull; typedef StyleChildrenIterator* StyleChildrenIteratorBorrowedMutOrNull; +typedef StyleChildrenIterator* StyleChildrenIteratorOwned; typedef StyleChildrenIterator const* StyleChildrenIteratorBorrowed; typedef StyleChildrenIterator* StyleChildrenIteratorBorrowedMut; +typedef ServoElementSnapshot* ServoElementSnapshotOwned; typedef ServoElementSnapshot const* ServoElementSnapshotBorrowed; typedef ServoElementSnapshot* ServoElementSnapshotBorrowedMut; + + + + + + +typedef RawGeckoNode const* RawGeckoNodeBorrowed; +typedef RawGeckoNode const* RawGeckoNodeBorrowedOrNull; +typedef RawGeckoElement const* RawGeckoElementBorrowed; +typedef RawGeckoElement const* RawGeckoElementBorrowedOrNull; +typedef RawGeckoDocument const* RawGeckoDocumentBorrowed; +typedef RawGeckoDocument const* RawGeckoDocumentBorrowedOrNull; +typedef StyleChildrenIterator* StyleChildrenIteratorBorrowedMut; +typedef ServoElementSnapshot* ServoElementSnapshotBorrowedMut; +typedef nsCSSValue const* nsCSSValueBorrowed; +typedef nsCSSValue* nsCSSValueBorrowedMut; +typedef RawGeckoPresContext* RawGeckoPresContextOwned; typedef RawGeckoPresContext const* RawGeckoPresContextBorrowed; typedef RawGeckoPresContext* RawGeckoPresContextBorrowedMut; +typedef RawGeckoPresContext const* RawGeckoPresContextBorrowed; +typedef RawGeckoAnimationValueList* RawGeckoAnimationValueListBorrowedMut; +typedef RawGeckoKeyframeList* RawGeckoKeyframeListBorrowedMut; +typedef RawGeckoKeyframeList const* RawGeckoKeyframeListBorrowed; +typedef RawGeckoComputedKeyframeValuesList* RawGeckoComputedKeyframeValuesListBorrowedMut; +typedef RawGeckoStyleAnimationList const* RawGeckoStyleAnimationListBorrowed; +typedef nsTimingFunction* nsTimingFunctionBorrowedMut; +typedef nsTimingFunction const* nsTimingFunctionBorrowed; +typedef RawGeckoFontFaceRuleList* RawGeckoFontFaceRuleListBorrowedMut; +typedef RawGeckoAnimationPropertySegment const* RawGeckoAnimationPropertySegmentBorrowed; +typedef RawGeckoComputedTiming const* RawGeckoComputedTimingBorrowed; +# 164 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoArcTypeList.h" 1 + + + + + + + + +extern "C" { void Servo_CssRules_AddRef( ServoCssRulesBorrowed ptr); void Servo_CssRules_Release( ServoCssRulesBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits { static void AddRef(ServoCssRules* aPtr) { Servo_CssRules_AddRef(aPtr); } static void Release(ServoCssRules* aPtr) { Servo_CssRules_Release(aPtr); } }; } +extern "C" { void Servo_StyleSheet_AddRef( RawServoStyleSheetBorrowed ptr); void Servo_StyleSheet_Release( RawServoStyleSheetBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits { static void AddRef(RawServoStyleSheet* aPtr) { Servo_StyleSheet_AddRef(aPtr); } static void Release(RawServoStyleSheet* aPtr) { Servo_StyleSheet_Release(aPtr); } }; } +extern "C" { void Servo_ComputedValues_AddRef( ServoComputedValuesBorrowed ptr); void Servo_ComputedValues_Release( ServoComputedValuesBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits { static void AddRef(ServoComputedValues* aPtr) { Servo_ComputedValues_AddRef(aPtr); } static void Release(ServoComputedValues* aPtr) { Servo_ComputedValues_Release(aPtr); } }; } +extern "C" { void Servo_DeclarationBlock_AddRef( RawServoDeclarationBlockBorrowed ptr); void Servo_DeclarationBlock_Release( RawServoDeclarationBlockBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits { static void AddRef(RawServoDeclarationBlock* aPtr) { Servo_DeclarationBlock_AddRef(aPtr); } static void Release(RawServoDeclarationBlock* aPtr) { Servo_DeclarationBlock_Release(aPtr); } }; } +extern "C" { void Servo_StyleRule_AddRef( RawServoStyleRuleBorrowed ptr); void Servo_StyleRule_Release( RawServoStyleRuleBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits { static void AddRef(RawServoStyleRule* aPtr) { Servo_StyleRule_AddRef(aPtr); } static void Release(RawServoStyleRule* aPtr) { Servo_StyleRule_Release(aPtr); } }; } +extern "C" { void Servo_ImportRule_AddRef( RawServoImportRuleBorrowed ptr); void Servo_ImportRule_Release( RawServoImportRuleBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits { static void AddRef(RawServoImportRule* aPtr) { Servo_ImportRule_AddRef(aPtr); } static void Release(RawServoImportRule* aPtr) { Servo_ImportRule_Release(aPtr); } }; } +extern "C" { void Servo_AnimationValue_AddRef( RawServoAnimationValueBorrowed ptr); void Servo_AnimationValue_Release( RawServoAnimationValueBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits { static void AddRef(RawServoAnimationValue* aPtr) { Servo_AnimationValue_AddRef(aPtr); } static void Release(RawServoAnimationValue* aPtr) { Servo_AnimationValue_Release(aPtr); } }; } +extern "C" { void Servo_AnimationValueMap_AddRef( RawServoAnimationValueMapBorrowed ptr); void Servo_AnimationValueMap_Release( RawServoAnimationValueMapBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits { static void AddRef(RawServoAnimationValueMap* aPtr) { Servo_AnimationValueMap_AddRef(aPtr); } static void Release(RawServoAnimationValueMap* aPtr) { Servo_AnimationValueMap_Release(aPtr); } }; } +extern "C" { void Servo_MediaList_AddRef( RawServoMediaListBorrowed ptr); void Servo_MediaList_Release( RawServoMediaListBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits { static void AddRef(RawServoMediaList* aPtr) { Servo_MediaList_AddRef(aPtr); } static void Release(RawServoMediaList* aPtr) { Servo_MediaList_Release(aPtr); } }; } +extern "C" { void Servo_MediaRule_AddRef( RawServoMediaRuleBorrowed ptr); void Servo_MediaRule_Release( RawServoMediaRuleBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits { static void AddRef(RawServoMediaRule* aPtr) { Servo_MediaRule_AddRef(aPtr); } static void Release(RawServoMediaRule* aPtr) { Servo_MediaRule_Release(aPtr); } }; } +extern "C" { void Servo_NamespaceRule_AddRef( RawServoNamespaceRuleBorrowed ptr); void Servo_NamespaceRule_Release( RawServoNamespaceRuleBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits { static void AddRef(RawServoNamespaceRule* aPtr) { Servo_NamespaceRule_AddRef(aPtr); } static void Release(RawServoNamespaceRule* aPtr) { Servo_NamespaceRule_Release(aPtr); } }; } +# 165 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 2 +# 181 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" +extern "C" void Servo_StyleSet_Drop( RawServoStyleSetOwned ptr); namespace mozilla { template<> class DefaultDelete { public: void operator()(RawServoStyleSet* aPtr) const { Servo_StyleSet_Drop(aPtr); } }; }; +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h" 1 +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h" +namespace mozilla { +# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h" +class EventStates +{ +public: + typedef uint64_t InternalType; + typedef uint64_t ServoType; + + constexpr EventStates() + : mStates(0) + { + } + + + + + + + explicit constexpr EventStates(InternalType aStates) + : mStates(aStates) + { + } + + EventStates constexpr operator|(const EventStates& aEventStates) const + { + return EventStates(mStates | aEventStates.mStates); + } + + EventStates& operator|=(const EventStates& aEventStates) + { + mStates |= aEventStates.mStates; + return *this; + } + + + + + EventStates constexpr operator&(const EventStates& aEventStates) const + { + return EventStates(mStates & aEventStates.mStates); + } + + EventStates& operator&=(const EventStates& aEventStates) + { + mStates &= aEventStates.mStates; + return *this; + } + + bool operator==(const EventStates& aEventStates) const + { + return mStates == aEventStates.mStates; + } + + bool operator!=(const EventStates& aEventStates) const + { + return mStates != aEventStates.mStates; + } + + EventStates operator~() const + { + return EventStates(~mStates); + } + + EventStates operator^(const EventStates& aEventStates) const + { + return EventStates(mStates ^ aEventStates.mStates); + } + + EventStates& operator^=(const EventStates& aEventStates) + { + mStates ^= aEventStates.mStates; + return *this; + } + + + + + + + + bool IsEmpty() const + { + return mStates == 0; + } +# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h" + bool HasState(EventStates aEventStates) const + { +# 124 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h" + return mStates & aEventStates.mStates; + } +# 135 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h" + bool HasAtLeastOneOfStates(EventStates aEventStates) const + { + return mStates & aEventStates.mStates; + } +# 148 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h" + bool HasAllStates(EventStates aEventStates) const + { + return (mStates & aEventStates.mStates) == aEventStates.mStates; + } + + + + InternalType GetInternalValue() const { + return mStates; + } + + + + + ServoType ServoValue() const + { + return mStates; + } + +private: + InternalType mStates; +}; + +} +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h" 2 + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BorrowedAttrInfo.h" 1 +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BorrowedAttrInfo.h" +class nsAttrName; +class nsAttrValue; + +namespace mozilla { +namespace dom { +# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BorrowedAttrInfo.h" +struct BorrowedAttrInfo +{ + BorrowedAttrInfo() + : mName(nullptr) + , mValue(nullptr) + { + } + + BorrowedAttrInfo(const nsAttrName* aName, const nsAttrValue* aValue); + + BorrowedAttrInfo(const BorrowedAttrInfo& aOther); + + const nsAttrName* mName; + const nsAttrValue* mValue; + + explicit operator bool() const { return mName != nullptr; } +}; + +} +} +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrName.h" 1 +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrName.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h" 1 +# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h" 1 +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" 1 +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAnnotations.h" 1 +# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h" 1 +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h" 1 +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h" +namespace mozilla { +# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h" +struct FloatTypeTraits +{ + typedef uint32_t Bits; + + static const unsigned kExponentBias = 127; + static const unsigned kExponentShift = 23; + + static const Bits kSignBit = 0x80000000UL; + static const Bits kExponentBits = 0x7F800000UL; + static const Bits kSignificandBits = 0x007FFFFFUL; +}; + +struct DoubleTypeTraits +{ + typedef uint64_t Bits; + + static const unsigned kExponentBias = 1023; + static const unsigned kExponentShift = 52; + + static const Bits kSignBit = 0x8000000000000000ULL; + static const Bits kExponentBits = 0x7ff0000000000000ULL; + static const Bits kSignificandBits = 0x000fffffffffffffULL; +}; + +template struct SelectTrait; +template<> struct SelectTrait : public FloatTypeTraits {}; +template<> struct SelectTrait : public DoubleTypeTraits {}; +# 91 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h" +template +struct FloatingPoint : public SelectTrait +{ + typedef SelectTrait Base; + typedef typename Base::Bits Bits; + + static_assert((Base::kSignBit & Base::kExponentBits) == 0, + "sign bit shouldn't overlap exponent bits"); + static_assert((Base::kSignBit & Base::kSignificandBits) == 0, + "sign bit shouldn't overlap significand bits"); + static_assert((Base::kExponentBits & Base::kSignificandBits) == 0, + "exponent bits shouldn't overlap significand bits"); + + static_assert((Base::kSignBit | Base::kExponentBits | Base::kSignificandBits) == + ~Bits(0), + "all bits accounted for"); +# 115 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h" + static_assert(sizeof(T) == sizeof(Bits), "Bits must be same size as T"); +}; + + +template +static __attribute__((always_inline)) inline bool +IsNaN(T aValue) +{ + + + + + typedef FloatingPoint Traits; + typedef typename Traits::Bits Bits; + return (BitwiseCast(aValue) & Traits::kExponentBits) == Traits::kExponentBits && + (BitwiseCast(aValue) & Traits::kSignificandBits) != 0; +} + + +template +static __attribute__((always_inline)) inline bool +IsInfinite(T aValue) +{ + + typedef FloatingPoint Traits; + typedef typename Traits::Bits Bits; + Bits bits = BitwiseCast(aValue); + return (bits & ~Traits::kSignBit) == Traits::kExponentBits; +} + + +template +static __attribute__((always_inline)) inline bool +IsFinite(T aValue) +{ + + + + + typedef FloatingPoint Traits; + typedef typename Traits::Bits Bits; + Bits bits = BitwiseCast(aValue); + return (bits & Traits::kExponentBits) != Traits::kExponentBits; +} + + + + + +template +static __attribute__((always_inline)) inline bool +IsNegative(T aValue) +{ + do { } while (0); + + + typedef FloatingPoint Traits; + typedef typename Traits::Bits Bits; + Bits bits = BitwiseCast(aValue); + return (bits & Traits::kSignBit) != 0; +} + + +template +static __attribute__((always_inline)) inline bool +IsNegativeZero(T aValue) +{ + + typedef FloatingPoint Traits; + typedef typename Traits::Bits Bits; + Bits bits = BitwiseCast(aValue); + return bits == Traits::kSignBit; +} + + +template +static __attribute__((always_inline)) inline bool +IsPositiveZero(T aValue) +{ + + typedef FloatingPoint Traits; + typedef typename Traits::Bits Bits; + Bits bits = BitwiseCast(aValue); + return bits == 0; +} + + + + + +template +static __attribute__((always_inline)) inline T +ToZeroIfNonfinite(T aValue) +{ + return IsFinite(aValue) ? aValue : 0; +} + + + + + + + +template +static __attribute__((always_inline)) inline int_fast16_t +ExponentComponent(T aValue) +{ + + + + + typedef FloatingPoint Traits; + typedef typename Traits::Bits Bits; + Bits bits = BitwiseCast(aValue); + return int_fast16_t((bits & Traits::kExponentBits) >> Traits::kExponentShift) - + int_fast16_t(Traits::kExponentBias); +} + + +template +static __attribute__((always_inline)) inline T +PositiveInfinity() +{ + + + + + typedef FloatingPoint Traits; + return BitwiseCast(Traits::kExponentBits); +} + + +template +static __attribute__((always_inline)) inline T +NegativeInfinity() +{ + + + + + typedef FloatingPoint Traits; + return BitwiseCast(Traits::kSignBit | Traits::kExponentBits); +} + + + + + +template::Bits Significand> +struct SpecificNaNBits +{ + using Traits = FloatingPoint; + + static_assert(SignBit == 0 || SignBit == 1, "bad sign bit"); + static_assert((Significand & ~Traits::kSignificandBits) == 0, + "significand must only have significand bits set"); + static_assert(Significand & Traits::kSignificandBits, + "significand must be nonzero"); + + static constexpr typename Traits::Bits value = + (SignBit * Traits::kSignBit) | Traits::kExponentBits | Significand; +}; +# 296 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h" +template +static __attribute__((always_inline)) inline void +SpecificNaN(int signbit, typename FloatingPoint::Bits significand, T* result) +{ + typedef FloatingPoint Traits; + do { } while (0); + do { } while (0); + do { } while (0); + + BitwiseCast((signbit ? Traits::kSignBit : 0) | + Traits::kExponentBits | + significand, + result); + do { } while (0); +} + +template +static __attribute__((always_inline)) inline T +SpecificNaN(int signbit, typename FloatingPoint::Bits significand) +{ + T t; + SpecificNaN(signbit, significand, &t); + return t; +} + + +template +static __attribute__((always_inline)) inline T +MinNumberValue() +{ + typedef FloatingPoint Traits; + typedef typename Traits::Bits Bits; + return BitwiseCast(Bits(1)); +} +# 338 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h" +template +static __attribute__((always_inline)) inline bool +NumberEqualsInt32(T aValue, int32_t* aInt32) +{ + + + + + + + return aValue == (*aInt32 = int32_t(aValue)); +} +# 358 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h" +template +static __attribute__((always_inline)) inline bool +NumberIsInt32(T aValue, int32_t* aInt32) +{ + return !IsNegativeZero(aValue) && NumberEqualsInt32(aValue, aInt32); +} + + + + + +template +static __attribute__((always_inline)) inline T +UnspecifiedNaN() +{ + + + + + + + typedef FloatingPoint Traits; + return SpecificNaN(1, Traits::kSignificandBits); +} + + + + + + +template +static inline bool +NumbersAreIdentical(T aValue1, T aValue2) +{ + typedef FloatingPoint Traits; + typedef typename Traits::Bits Bits; + if (IsNaN(aValue1)) { + return IsNaN(aValue2); + } + return BitwiseCast(aValue1) == BitwiseCast(aValue2); +} + +namespace detail { + +template +struct FuzzyEqualsEpsilon; + +template<> +struct FuzzyEqualsEpsilon +{ + + static float value() { return 1.0f / (1 << 17); } +}; + +template<> +struct FuzzyEqualsEpsilon +{ + + static double value() { return 1.0 / (1LL << 40); } +}; + +} +# 433 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h" +template +static __attribute__((always_inline)) inline bool +FuzzyEqualsAdditive(T aValue1, T aValue2, + T aEpsilon = detail::FuzzyEqualsEpsilon::value()) +{ + static_assert(IsFloatingPoint::value, "floating point type required"); + return Abs(aValue1 - aValue2) <= aEpsilon; +} +# 454 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h" +template +static __attribute__((always_inline)) inline bool +FuzzyEqualsMultiplicative(T aValue1, T aValue2, + T aEpsilon = detail::FuzzyEqualsEpsilon::value()) +{ + static_assert(IsFloatingPoint::value, "floating point type required"); + + T smaller = Abs(aValue1) < Abs(aValue2) ? Abs(aValue1) : Abs(aValue2); + return Abs(aValue1 - aValue2) <= aEpsilon * smaller; +} +# 473 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h" +__attribute__ ((warn_unused_result)) +extern __attribute__((weak)) __attribute__((visibility("default"))) bool +IsFloat32Representable(double aFloat32); + +} +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h" 2 + + + +namespace IPC { +template struct ParamTraits; +} + + + + + + + +namespace mozilla { + + +typedef uint64_t TimeStampValue; + + +class TimeStamp; + + + + +class BaseTimeDurationPlatformUtils +{ +public: + static __attribute__((weak)) __attribute__((visibility("default"))) double ToSeconds(int64_t aTicks); + static __attribute__((weak)) __attribute__((visibility("default"))) double ToSecondsSigDigits(int64_t aTicks); + static __attribute__((weak)) __attribute__((visibility("default"))) int64_t TicksFromMilliseconds(double aMilliseconds); + static __attribute__((weak)) __attribute__((visibility("default"))) int64_t ResolutionInTicks(); +}; +# 62 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h" +template +class BaseTimeDuration +{ +public: + + constexpr BaseTimeDuration() : mValue(0) {} + + + struct _SomethingVeryRandomHere; + BaseTimeDuration(_SomethingVeryRandomHere* aZero) : mValue(0) + { + do { } while (0); + } + + + + template + explicit BaseTimeDuration(const BaseTimeDuration& aOther) + : mValue(aOther.mValue) + { } + + template + BaseTimeDuration& operator=(const BaseTimeDuration& aOther) + { + mValue = aOther.mValue; + return *this; + } + + double ToSeconds() const + { + if (mValue == (9223372036854775807L)) { + return PositiveInfinity(); + } + if (mValue == (-9223372036854775807L -1)) { + return NegativeInfinity(); + } + return BaseTimeDurationPlatformUtils::ToSeconds(mValue); + } + + + + double ToSecondsSigDigits() const + { + if (mValue == (9223372036854775807L)) { + return PositiveInfinity(); + } + if (mValue == (-9223372036854775807L -1)) { + return NegativeInfinity(); + } + return BaseTimeDurationPlatformUtils::ToSecondsSigDigits(mValue); + } + double ToMilliseconds() const { return ToSeconds() * 1000.0; } + double ToMicroseconds() const { return ToMilliseconds() * 1000.0; } + + + + + + + static inline BaseTimeDuration FromSeconds(double aSeconds) + { + return FromMilliseconds(aSeconds * 1000.0); + } + static BaseTimeDuration FromMilliseconds(double aMilliseconds) + { + if (aMilliseconds == PositiveInfinity()) { + return Forever(); + } + if (aMilliseconds == NegativeInfinity()) { + return FromTicks((-9223372036854775807L -1)); + } + return FromTicks( + BaseTimeDurationPlatformUtils::TicksFromMilliseconds(aMilliseconds)); + } + static inline BaseTimeDuration FromMicroseconds(double aMicroseconds) + { + return FromMilliseconds(aMicroseconds / 1000.0); + } + + static BaseTimeDuration Forever() + { + return FromTicks((9223372036854775807L)); + } + + BaseTimeDuration operator+(const BaseTimeDuration& aOther) const + { + return FromTicks(ValueCalculator::Add(mValue, aOther.mValue)); + } + BaseTimeDuration operator-(const BaseTimeDuration& aOther) const + { + return FromTicks(ValueCalculator::Subtract(mValue, aOther.mValue)); + } + BaseTimeDuration& operator+=(const BaseTimeDuration& aOther) + { + mValue = ValueCalculator::Add(mValue, aOther.mValue); + return *this; + } + BaseTimeDuration& operator-=(const BaseTimeDuration& aOther) + { + mValue = ValueCalculator::Subtract(mValue, aOther.mValue); + return *this; + } + BaseTimeDuration operator-() const + { + + + int64_t ticks; + if (mValue == (9223372036854775807L)) { + ticks = (-9223372036854775807L -1); + } else if (mValue == (-9223372036854775807L -1)) { + ticks = (9223372036854775807L); + } else { + ticks = -mValue; + } + + return FromTicks(ticks); + } + + static BaseTimeDuration Max(const BaseTimeDuration& aA, + const BaseTimeDuration& aB) + { + return FromTicks(std::max(aA.mValue, aB.mValue)); + } + static BaseTimeDuration Min(const BaseTimeDuration& aA, + const BaseTimeDuration& aB) + { + return FromTicks(std::min(aA.mValue, aB.mValue)); + } + +private: + + + BaseTimeDuration operator*(const double aMultiplier) const = delete; + + + + + BaseTimeDuration operator/(const double aDivisor) const = delete; + +public: + BaseTimeDuration MultDouble(double aMultiplier) const + { + return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier)); + } + BaseTimeDuration operator*(const int32_t aMultiplier) const + { + return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier)); + } + BaseTimeDuration operator*(const uint32_t aMultiplier) const + { + return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier)); + } + BaseTimeDuration operator*(const int64_t aMultiplier) const + { + return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier)); + } + BaseTimeDuration operator*(const uint64_t aMultiplier) const + { + if (aMultiplier > (9223372036854775807L)) { + return Forever(); + } + return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier)); + } + BaseTimeDuration operator/(const int64_t aDivisor) const + { + do { } while (0); + return FromTicks(ValueCalculator::Divide(mValue, aDivisor)); + } + double operator/(const BaseTimeDuration& aOther) const + { + + + do { } while (0); + + return ValueCalculator::DivideDouble(mValue, aOther.mValue); + } + BaseTimeDuration operator%(const BaseTimeDuration& aOther) const + { + do { } while (0); + return FromTicks(ValueCalculator::Modulo(mValue, aOther.mValue)); + } + + template + bool operator<(const BaseTimeDuration& aOther) const + { + return mValue < aOther.mValue; + } + template + bool operator<=(const BaseTimeDuration& aOther) const + { + return mValue <= aOther.mValue; + } + template + bool operator>=(const BaseTimeDuration& aOther) const + { + return mValue >= aOther.mValue; + } + template + bool operator>(const BaseTimeDuration& aOther) const + { + return mValue > aOther.mValue; + } + template + bool operator==(const BaseTimeDuration& aOther) const + { + return mValue == aOther.mValue; + } + template + bool operator!=(const BaseTimeDuration& aOther) const + { + return mValue != aOther.mValue; + } + bool IsZero() const + { + return mValue == 0; + } + explicit operator bool() const + { + return mValue != 0; + } + + friend std::ostream& operator<<(std::ostream& aStream, + const BaseTimeDuration& aDuration) { + return aStream << aDuration.ToMilliseconds() << " ms"; + } + + + + + + static BaseTimeDuration Resolution() { + return FromTicks(BaseTimeDurationPlatformUtils::ResolutionInTicks()); + } +# 303 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h" +private: + friend class TimeStamp; + friend struct IPC::ParamTraits>; + template + friend class BaseTimeDuration; + + static BaseTimeDuration FromTicks(int64_t aTicks) + { + BaseTimeDuration t; + t.mValue = aTicks; + return t; + } + + static BaseTimeDuration FromTicks(double aTicks) + { + + + if (aTicks >= double((9223372036854775807L))) { + return FromTicks((9223372036854775807L)); + } + + + if (aTicks <= double((-9223372036854775807L -1))) { + return FromTicks((-9223372036854775807L -1)); + } + + return FromTicks(int64_t(aTicks)); + } + + + int64_t mValue; +}; + + + + + +class TimeDurationValueCalculator +{ +public: + static int64_t Add(int64_t aA, int64_t aB) { return aA + aB; } + static int64_t Subtract(int64_t aA, int64_t aB) { return aA - aB; } + + template + static int64_t Multiply(int64_t aA, T aB) + { + static_assert(IsIntegral::value, + "Using integer multiplication routine with non-integer type." + " Further specialization required"); + return aA * static_cast(aB); + } + + static int64_t Divide(int64_t aA, int64_t aB) { return aA / aB; } + static double DivideDouble(int64_t aA, int64_t aB) + { + return static_cast(aA) / aB; + } + static int64_t Modulo(int64_t aA, int64_t aB) { return aA % aB; } +}; + +template <> +inline int64_t +TimeDurationValueCalculator::Multiply(int64_t aA, double aB) +{ + return static_cast(aA * aB); +} +# 378 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h" +typedef BaseTimeDuration TimeDuration; +# 410 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h" +class TimeStamp +{ +public: + + + + constexpr TimeStamp() : mValue(0) {} +# 443 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h" + bool IsNull() const { return mValue == 0; } + + + + + + explicit operator bool() const + { + return mValue != 0; + } +# 467 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h" + static TimeStamp Now() { return Now(true); } + static TimeStamp NowLoRes() { return Now(false); } +# 482 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h" + static __attribute__((weak)) __attribute__((visibility("default"))) TimeStamp ProcessCreation(bool& aIsInconsistent); + + + + + + + static __attribute__((weak)) __attribute__((visibility("default"))) void RecordProcessRestart(); + + + + + TimeDuration operator-(const TimeStamp& aOther) const + { + do { } while (0); + do { } while (0); + static_assert(-(9223372036854775807L) > (-9223372036854775807L -1), "int64_t sanity check"); + int64_t ticks = int64_t(mValue - aOther.mValue); + + if (mValue > aOther.mValue) { + if (ticks < 0) { + ticks = (9223372036854775807L); + } + } else { + if (ticks > 0) { + ticks = (-9223372036854775807L -1); + } + } + return TimeDuration::FromTicks(ticks); + } + + TimeStamp operator+(const TimeDuration& aOther) const + { + TimeStamp result = *this; + result += aOther; + return result; + } + TimeStamp operator-(const TimeDuration& aOther) const + { + TimeStamp result = *this; + result -= aOther; + return result; + } + TimeStamp& operator+=(const TimeDuration& aOther) + { + do { } while (0); + TimeStampValue value = mValue + aOther.mValue; + + + + if (aOther.mValue < 0 && value > mValue) { + value = 0; + } + mValue = value; + return *this; + } + TimeStamp& operator-=(const TimeDuration& aOther) + { + do { } while (0); + TimeStampValue value = mValue - aOther.mValue; + + + + if (aOther.mValue > 0 && value > mValue) { + value = 0; + } + mValue = value; + return *this; + } + + bool operator<(const TimeStamp& aOther) const + { + do { } while (0); + do { } while (0); + return mValue < aOther.mValue; + } + bool operator<=(const TimeStamp& aOther) const + { + do { } while (0); + do { } while (0); + return mValue <= aOther.mValue; + } + bool operator>=(const TimeStamp& aOther) const + { + do { } while (0); + do { } while (0); + return mValue >= aOther.mValue; + } + bool operator>(const TimeStamp& aOther) const + { + do { } while (0); + do { } while (0); + return mValue > aOther.mValue; + } + bool operator==(const TimeStamp& aOther) const + { + return IsNull() + ? aOther.IsNull() + : !aOther.IsNull() && mValue == aOther.mValue; + } + bool operator!=(const TimeStamp& aOther) const + { + return !(*this == aOther); + } + + + + + + static __attribute__((weak)) __attribute__((visibility("default"))) void Startup(); + static __attribute__((weak)) __attribute__((visibility("default"))) void Shutdown(); + +private: + friend struct IPC::ParamTraits; + friend void StartupTimelineRecordExternal(int, uint64_t); + + TimeStamp(TimeStampValue aValue) : mValue(aValue) {} + + static __attribute__((weak)) __attribute__((visibility("default"))) TimeStamp Now(bool aHighResolution); +# 610 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h" + static __attribute__((weak)) __attribute__((visibility("default"))) uint64_t ComputeProcessUptime(); +# 625 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h" + TimeStampValue mValue; +}; + +} +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" 1 +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AllocPolicy.h" 1 +# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AllocPolicy.h" +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 +# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AllocPolicy.h" 2 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3 +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AllocPolicy.h" 2 + +namespace mozilla { +# 71 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AllocPolicy.h" +class MallocAllocPolicy +{ +public: + template + T* maybe_pod_malloc(size_t aNumElems) + { + if (aNumElems & mozilla::tl::MulOverflowMask::value) { + return nullptr; + } + return static_cast(malloc(aNumElems * sizeof(T))); + } + + template + T* maybe_pod_calloc(size_t aNumElems) + { + return static_cast(calloc(aNumElems, sizeof(T))); + } + + template + T* maybe_pod_realloc(T* aPtr, size_t aOldSize, size_t aNewSize) + { + if (aNewSize & mozilla::tl::MulOverflowMask::value) { + return nullptr; + } + return static_cast(realloc(aPtr, aNewSize * sizeof(T))); + } + + template + T* pod_malloc(size_t aNumElems) + { + return maybe_pod_malloc(aNumElems); + } + + template + T* pod_calloc(size_t aNumElems) + { + return maybe_pod_calloc(aNumElems); + } + + template + T* pod_realloc(T* aPtr, size_t aOldSize, size_t aNewSize) + { + return maybe_pod_realloc(aPtr, aOldSize, aNewSize); + } + + void free_(void* aPtr) + { + free(aPtr); + } + + void reportAllocOverflow() const + { + } + + __attribute__ ((warn_unused_result)) bool checkSimulatedOOM() const + { + return true; + } +}; + +} +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" 2 + + + + + + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ReentrancyGuard.h" 1 +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ReentrancyGuard.h" +namespace mozilla { + + +class ReentrancyGuard +{ + + + + + +public: + template + + + + + + explicit ReentrancyGuard(T& + ) + + { + do { } while (0); + + + + + } + ~ReentrancyGuard() + { + + + + } + +private: + ReentrancyGuard(const ReentrancyGuard&) = delete; + void operator=(const ReentrancyGuard&) = delete; +}; + +} +# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" 2 +# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" +namespace mozilla { + +template +class Vector; + +namespace detail { + + + + + + +template +static bool CapacityHasExcessSpace(size_t aCapacity) +{ + size_t size = aCapacity * sizeof(T); + return RoundUpPow2(size) - size >= sizeof(T); +} + + + + + +template +struct VectorImpl +{ + + + + template + __attribute__ ((nonnull(1))) + static inline void new_(T* aDst, Args&&... aArgs) + { + new(KnownNotNull, aDst) T(Forward(aArgs)...); + } + + + static inline void destroy(T* aBegin, T* aEnd) + { + do { } while (0); + for (T* p = aBegin; p < aEnd; ++p) { + p->~T(); + } + } + + + static inline void initialize(T* aBegin, T* aEnd) + { + do { } while (0); + for (T* p = aBegin; p < aEnd; ++p) { + new_(p); + } + } + + + + + + template + static inline void copyConstruct(T* aDst, + const U* aSrcStart, const U* aSrcEnd) + { + do { } while (0); + for (const U* p = aSrcStart; p < aSrcEnd; ++p, ++aDst) { + new_(aDst, *p); + } + } + + + + + + template + static inline void moveConstruct(T* aDst, U* aSrcStart, U* aSrcEnd) + { + do { } while (0); + for (U* p = aSrcStart; p < aSrcEnd; ++p, ++aDst) { + new_(aDst, Move(*p)); + } + } + + + + + + template + static inline void copyConstructN(T* aDst, size_t aN, const U& aU) + { + for (T* end = aDst + aN; aDst < end; ++aDst) { + new_(aDst, aU); + } + } + + + + + + + + static inline __attribute__ ((warn_unused_result)) bool + growTo(Vector& aV, size_t aNewCap) + { + do { } while (0); + do { } while (0); + T* newbuf = aV.template pod_malloc(aNewCap); + if ((__builtin_expect(!!(!newbuf), 0))) { + return false; + } + T* dst = newbuf; + T* src = aV.beginNoCheck(); + for (; src < aV.endNoCheck(); ++dst, ++src) { + new_(dst, Move(*src)); + } + VectorImpl::destroy(aV.beginNoCheck(), aV.endNoCheck()); + aV.free_(aV.mBegin); + aV.mBegin = newbuf; + + aV.mTail.mCapacity = aNewCap; + return true; + } +}; + + + + + + +template +struct VectorImpl +{ + template + __attribute__ ((nonnull(1))) + static inline void new_(T* aDst, Args&&... aArgs) + { + + + + + T temp(Forward(aArgs)...); + *aDst = temp; + } + + static inline void destroy(T*, T*) {} + + static inline void initialize(T* aBegin, T* aEnd) + { +# 187 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" + do { } while (0); + for (T* p = aBegin; p < aEnd; ++p) { + new_(p); + } + } + + template + static inline void copyConstruct(T* aDst, + const U* aSrcStart, const U* aSrcEnd) + { + + + + + + + + do { } while (0); + for (const U* p = aSrcStart; p < aSrcEnd; ++p, ++aDst) { + new_(aDst, *p); + } + } + + template + static inline void moveConstruct(T* aDst, + const U* aSrcStart, const U* aSrcEnd) + { + copyConstruct(aDst, aSrcStart, aSrcEnd); + } + + static inline void copyConstructN(T* aDst, size_t aN, const T& aT) + { + for (T* end = aDst + aN; aDst < end; ++aDst) { + new_(aDst, aT); + } + } + + static inline __attribute__ ((warn_unused_result)) bool + growTo(Vector& aV, size_t aNewCap) + { + do { } while (0); + do { } while (0); + T* newbuf = + aV.template pod_realloc(aV.mBegin, aV.mTail.mCapacity, aNewCap); + if ((__builtin_expect(!!(!newbuf), 0))) { + return false; + } + aV.mBegin = newbuf; + + aV.mTail.mCapacity = aNewCap; + return true; + } + + static inline void + podResizeToFit(Vector& aV) + { + if (aV.usingInlineStorage() || aV.mLength == aV.mTail.mCapacity) { + return; + } + T* newbuf = + aV.template pod_realloc(aV.mBegin, aV.mTail.mCapacity, aV.mLength); + if ((__builtin_expect(!!(!newbuf), 0))) { + return; + } + aV.mBegin = newbuf; + aV.mTail.mCapacity = aV.mLength; + } +}; + + + +struct VectorTesting; + +} +# 280 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" +template +class Vector final : private AllocPolicy +{ + + + static const bool kElemIsPod = IsPod::value; + typedef detail::VectorImpl Impl; + friend struct detail::VectorImpl; + + friend struct detail::VectorTesting; + + __attribute__ ((warn_unused_result)) bool growStorageBy(size_t aIncr); + __attribute__ ((warn_unused_result)) bool convertToHeapStorage(size_t aNewCap); + __attribute__ ((warn_unused_result)) bool maybeCheckSimulatedOOM(size_t aRequestedSize); +# 305 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" + static constexpr size_t kMaxInlineBytes = + 1024 - (sizeof(AllocPolicy) + sizeof(T*) + sizeof(size_t) + sizeof(size_t)); +# 317 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" + template + struct ComputeCapacity + { + static constexpr size_t value = + tl::Min::value; + }; + + template + struct ComputeCapacity<0, Dummy> + { + static constexpr size_t value = 0; + }; + + + static constexpr size_t kInlineCapacity = + ComputeCapacity::value; +# 343 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" + T* mBegin; + + + size_t mLength; +# 367 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" + struct CapacityAndReserved + { + explicit CapacityAndReserved(size_t aCapacity, size_t aReserved) + : mCapacity(aCapacity) + + + + {} + CapacityAndReserved() = default; + + + size_t mCapacity; + + + + + + }; +# 393 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" + template + struct CRAndStorage : CapacityAndReserved + { + explicit CRAndStorage(size_t aCapacity, size_t aReserved) + : CapacityAndReserved(aCapacity, aReserved) + {} + CRAndStorage() = default; + + alignas(T) unsigned char mBytes[Capacity * sizeof(T)]; + + + + void* data() { return mBytes; } + + T* storage() { return static_cast(data()); } + }; + + template + struct CRAndStorage<0, Dummy> : CapacityAndReserved + { + explicit CRAndStorage(size_t aCapacity, size_t aReserved) + : CapacityAndReserved(aCapacity, aReserved) + {} + CRAndStorage() = default; + + T* storage() { return nullptr; } + }; + + CRAndStorage mTail; +# 434 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" + bool usingInlineStorage() const + { + return mBegin == const_cast(this)->inlineStorage(); + } + + T* inlineStorage() + { + return mTail.storage(); + } + + T* beginNoCheck() const + { + return mBegin; + } + + T* endNoCheck() + { + return mBegin + mLength; + } + + const T* endNoCheck() const + { + return mBegin + mLength; + } +# 476 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" + template void internalAppend(U&& aU); + template + void internalAppendAll(const Vector& aU); + void internalAppendN(const T& aT, size_t aN); + template void internalAppend(const U* aBegin, size_t aLength); + +public: + static const size_t sMaxInlineStorage = MinInlineCapacity; + + typedef T ElementType; + + explicit Vector(AllocPolicy = AllocPolicy()); + Vector(Vector&&); + Vector& operator=(Vector&&); + ~Vector(); + + + + const AllocPolicy& allocPolicy() const { return *this; } + + AllocPolicy& allocPolicy() { return *this; } + + enum { InlineLength = MinInlineCapacity }; + + size_t length() const { return mLength; } + + bool empty() const { return mLength == 0; } + + size_t capacity() const { return mTail.mCapacity; } + + T* begin() + { + do { } while (0); + return mBegin; + } + + const T* begin() const + { + do { } while (0); + return mBegin; + } + + T* end() + { + do { } while (0); + return mBegin + mLength; + } + + const T* end() const + { + do { } while (0); + return mBegin + mLength; + } + + T& operator[](size_t aIndex) + { + do { } while (0); + do { } while (0); + return begin()[aIndex]; + } + + const T& operator[](size_t aIndex) const + { + do { } while (0); + do { } while (0); + return begin()[aIndex]; + } + + T& back() + { + do { } while (0); + do { } while (0); + return *(end() - 1); + } + + const T& back() const + { + do { } while (0); + do { } while (0); + return *(end() - 1); + } + + class Range + { + friend class Vector; + T* mCur; + T* mEnd; + Range(T* aCur, T* aEnd) + : mCur(aCur) + , mEnd(aEnd) + { + do { } while (0); + } + + public: + bool empty() const { return mCur == mEnd; } + size_t remain() const { return PointerRangeSize(mCur, mEnd); } + T& front() const { do { } while (0); return *mCur; } + void popFront() { do { } while (0); ++mCur; } + T popCopyFront() { do { } while (0); return *mCur++; } + }; + + class ConstRange + { + friend class Vector; + const T* mCur; + const T* mEnd; + ConstRange(const T* aCur, const T* aEnd) + : mCur(aCur) + , mEnd(aEnd) + { + do { } while (0); + } + + public: + bool empty() const { return mCur == mEnd; } + size_t remain() const { return PointerRangeSize(mCur, mEnd); } + const T& front() const { do { } while (0); return *mCur; } + void popFront() { do { } while (0); ++mCur; } + T popCopyFront() { do { } while (0); return *mCur++; } + }; + + Range all() { return Range(begin(), end()); } + ConstRange all() const { return ConstRange(begin(), end()); } + + + + + + + void reverse(); + + + + + + __attribute__ ((warn_unused_result)) bool initCapacity(size_t aRequest); +# 621 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" + __attribute__ ((warn_unused_result)) bool initLengthUninitialized(size_t aRequest); +# 631 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" + __attribute__ ((warn_unused_result)) bool reserve(size_t aRequest); + + + + + + void shrinkBy(size_t aIncr); + + + + + + void shrinkTo(size_t aNewLength); + + + __attribute__ ((warn_unused_result)) bool growBy(size_t aIncr); + + + __attribute__ ((warn_unused_result)) bool resize(size_t aNewLength); + + + + + + __attribute__ ((warn_unused_result)) bool growByUninitialized(size_t aIncr); + void infallibleGrowByUninitialized(size_t aIncr); + __attribute__ ((warn_unused_result)) bool resizeUninitialized(size_t aNewLength); + + + void clear(); + + + void clearAndFree(); + + + + + + + void podResizeToFit(); + + + + + + + + bool canAppendWithoutRealloc(size_t aNeeded) const; +# 687 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" + template __attribute__ ((warn_unused_result)) bool append(U&& aU); + + + + + template + __attribute__ ((warn_unused_result)) bool emplaceBack(Args&&... aArgs) + { + if (!growByUninitialized(1)) + return false; + Impl::new_(&back(), Forward(aArgs)...); + return true; + } + + template + __attribute__ ((warn_unused_result)) bool appendAll(const Vector& aU); + __attribute__ ((warn_unused_result)) bool appendN(const T& aT, size_t aN); + template __attribute__ ((warn_unused_result)) bool append(const U* aBegin, const U* aEnd); + template __attribute__ ((warn_unused_result)) bool append(const U* aBegin, size_t aLength); + + + + + + + template void infallibleAppend(U&& aU) + { + internalAppend(Forward(aU)); + } + void infallibleAppendN(const T& aT, size_t aN) + { + internalAppendN(aT, aN); + } + template void infallibleAppend(const U* aBegin, const U* aEnd) + { + internalAppend(aBegin, PointerRangeSize(aBegin, aEnd)); + } + template void infallibleAppend(const U* aBegin, size_t aLength) + { + internalAppend(aBegin, aLength); + } + template + void infallibleEmplaceBack(Args&&... aArgs) + { + infallibleGrowByUninitialized(1); + Impl::new_(&back(), Forward(aArgs)...); + } + + void popBack(); + + T popCopy(); +# 749 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" + __attribute__ ((warn_unused_result)) T* extractRawBuffer(); +# 767 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" + __attribute__ ((warn_unused_result)) T* extractOrCopyRawBuffer(); +# 777 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" + void replaceRawBuffer(T* aP, size_t aLength); +# 794 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" + template + __attribute__ ((warn_unused_result)) T* insert(T* aP, U&& aVal); + + + + + + void erase(T* aT); + + + + + + + void erase(T* aBegin, T* aEnd); + + + + + size_t sizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const; + + + + + + size_t sizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const; + + void swap(Vector& aOther); + +private: + Vector(const Vector&) = delete; + void operator=(const Vector&) = delete; +}; +# 838 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" +template +__attribute__((always_inline)) inline +Vector::Vector(AP aAP) + : AP(aAP) + , mLength(0) + , mTail(kInlineCapacity, 0) + + + +{ + mBegin = inlineStorage(); +} + + +template +__attribute__((always_inline)) inline +Vector::Vector(Vector&& aRhs) + : AllocPolicy(Move(aRhs)) + + + +{ + mLength = aRhs.mLength; + mTail.mCapacity = aRhs.mTail.mCapacity; + + + + + if (aRhs.usingInlineStorage()) { + + mBegin = inlineStorage(); + Impl::moveConstruct(mBegin, aRhs.beginNoCheck(), aRhs.endNoCheck()); + + + + + } else { + + + + + mBegin = aRhs.mBegin; + aRhs.mBegin = aRhs.inlineStorage(); + aRhs.mTail.mCapacity = kInlineCapacity; + aRhs.mLength = 0; + + + + } +} + + +template +__attribute__((always_inline)) inline Vector& +Vector::operator=(Vector&& aRhs) +{ + do { } while (0); + this->~Vector(); + new(KnownNotNull, this) Vector(Move(aRhs)); + return *this; +} + +template +__attribute__((always_inline)) inline +Vector::~Vector() +{ + ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0); + Impl::destroy(beginNoCheck(), endNoCheck()); + if (!usingInlineStorage()) { + this->free_(beginNoCheck()); + } +} + +template +__attribute__((always_inline)) inline void +Vector::reverse() { + ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0); + T* elems = mBegin; + size_t len = mLength; + size_t mid = len / 2; + for (size_t i = 0; i < mid; i++) { + Swap(elems[i], elems[len - i - 1]); + } +} + + + + + + +template +inline bool +Vector::convertToHeapStorage(size_t aNewCap) +{ + do { } while (0); + + + do { } while (0); + T* newBuf = this->template pod_malloc(aNewCap); + if ((__builtin_expect(!!(!newBuf), 0))) { + return false; + } + + + Impl::moveConstruct(newBuf, beginNoCheck(), endNoCheck()); + Impl::destroy(beginNoCheck(), endNoCheck()); + + + mBegin = newBuf; + + mTail.mCapacity = aNewCap; + return true; +} + +template +__attribute__((noinline)) bool +Vector::growStorageBy(size_t aIncr) +{ + do { } while (0); +# 966 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" + size_t newCap; + + if (aIncr == 1) { + if (usingInlineStorage()) { + + size_t newSize = + tl::RoundUpPow2<(kInlineCapacity + 1) * sizeof(T)>::value; + newCap = newSize / sizeof(T); + goto convert; + } + + if (mLength == 0) { + + newCap = 1; + goto grow; + } +# 994 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" + if ((__builtin_expect(!!(mLength & tl::MulOverflowMask<4 * sizeof(T)>::value), 0))) { + this->reportAllocOverflow(); + return false; + } + + + + + + + newCap = mLength * 2; + if (detail::CapacityHasExcessSpace(newCap)) { + newCap += 1; + } + } else { + + size_t newMinCap = mLength + aIncr; + + + if ((__builtin_expect(!!(newMinCap < mLength || newMinCap & tl::MulOverflowMask<2 * sizeof(T)>::value), 0))) + + { + this->reportAllocOverflow(); + return false; + } + + size_t newMinSize = newMinCap * sizeof(T); + size_t newSize = RoundUpPow2(newMinSize); + newCap = newSize / sizeof(T); + } + + if (usingInlineStorage()) { +convert: + return convertToHeapStorage(newCap); + } + +grow: + return Impl::growTo(*this, newCap); +} + +template +inline bool +Vector::initCapacity(size_t aRequest) +{ + do { } while (0); + do { } while (0); + if (aRequest == 0) { + return true; + } + T* newbuf = this->template pod_malloc(aRequest); + if ((__builtin_expect(!!(!newbuf), 0))) { + return false; + } + mBegin = newbuf; + mTail.mCapacity = aRequest; + + + + return true; +} + +template +inline bool +Vector::initLengthUninitialized(size_t aRequest) +{ + if (!initCapacity(aRequest)) { + return false; + } + infallibleGrowByUninitialized(aRequest); + return true; +} + +template +inline bool +Vector::maybeCheckSimulatedOOM(size_t aRequestedSize) +{ + if (aRequestedSize <= N) { + return true; + } + + + + + + + + return allocPolicy().checkSimulatedOOM(); +} + +template +inline bool +Vector::reserve(size_t aRequest) +{ + ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0); + if (aRequest > mTail.mCapacity) { + if ((__builtin_expect(!!(!growStorageBy(aRequest - mLength)), 0))) { + return false; + } + } else if (!maybeCheckSimulatedOOM(aRequest)) { + return false; + } + + + + + + + + return true; +} + +template +inline void +Vector::shrinkBy(size_t aIncr) +{ + ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0); + do { } while (0); + Impl::destroy(endNoCheck() - aIncr, endNoCheck()); + mLength -= aIncr; +} + +template +__attribute__((always_inline)) inline void +Vector::shrinkTo(size_t aNewLength) +{ + do { } while (0); + shrinkBy(mLength - aNewLength); +} + +template +__attribute__((always_inline)) inline bool +Vector::growBy(size_t aIncr) +{ + ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0); + if (aIncr > mTail.mCapacity - mLength) { + if ((__builtin_expect(!!(!growStorageBy(aIncr)), 0))) { + return false; + } + } else if (!maybeCheckSimulatedOOM(mLength + aIncr)) { + return false; + } + do { } while (0); + T* newend = endNoCheck() + aIncr; + Impl::initialize(endNoCheck(), newend); + mLength += aIncr; + + + + + + return true; +} + +template +__attribute__((always_inline)) inline bool +Vector::growByUninitialized(size_t aIncr) +{ + ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0); + if (aIncr > mTail.mCapacity - mLength) { + if ((__builtin_expect(!!(!growStorageBy(aIncr)), 0))) { + return false; + } + } else if (!maybeCheckSimulatedOOM(mLength + aIncr)) { + return false; + } + + + + + + infallibleGrowByUninitialized(aIncr); + return true; +} + +template +__attribute__((always_inline)) inline void +Vector::infallibleGrowByUninitialized(size_t aIncr) +{ + do { } while (0); + mLength += aIncr; +} + +template +inline bool +Vector::resize(size_t aNewLength) +{ + size_t curLength = mLength; + if (aNewLength > curLength) { + return growBy(aNewLength - curLength); + } + shrinkBy(curLength - aNewLength); + return true; +} + +template +__attribute__((always_inline)) inline bool +Vector::resizeUninitialized(size_t aNewLength) +{ + size_t curLength = mLength; + if (aNewLength > curLength) { + return growByUninitialized(aNewLength - curLength); + } + shrinkBy(curLength - aNewLength); + return true; +} + +template +inline void +Vector::clear() +{ + ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0); + Impl::destroy(beginNoCheck(), endNoCheck()); + mLength = 0; +} + +template +inline void +Vector::clearAndFree() +{ + clear(); + + if (usingInlineStorage()) { + return; + } + this->free_(beginNoCheck()); + mBegin = inlineStorage(); + mTail.mCapacity = kInlineCapacity; + + + +} + +template +inline void +Vector::podResizeToFit() +{ + + + Impl::podResizeToFit(*this); +} + +template +inline bool +Vector::canAppendWithoutRealloc(size_t aNeeded) const +{ + return mLength + aNeeded <= mTail.mCapacity; +} + +template +template +__attribute__((always_inline)) inline void +Vector::internalAppendAll(const Vector& aOther) +{ + internalAppend(aOther.begin(), aOther.length()); +} + +template +template +__attribute__((always_inline)) inline void +Vector::internalAppend(U&& aU) +{ + do { } while (0); + do { } while (0); + Impl::new_(endNoCheck(), Forward(aU)); + ++mLength; +} + +template +__attribute__((always_inline)) inline bool +Vector::appendN(const T& aT, size_t aNeeded) +{ + ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0); + if (mLength + aNeeded > mTail.mCapacity) { + if ((__builtin_expect(!!(!growStorageBy(aNeeded)), 0))) { + return false; + } + } else if (!maybeCheckSimulatedOOM(mLength + aNeeded)) { + return false; + } + + + + + + internalAppendN(aT, aNeeded); + return true; +} + +template +__attribute__((always_inline)) inline void +Vector::internalAppendN(const T& aT, size_t aNeeded) +{ + do { } while (0); + do { } while (0); + Impl::copyConstructN(endNoCheck(), aNeeded, aT); + mLength += aNeeded; +} + +template +template +inline T* +Vector::insert(T* aP, U&& aVal) +{ + do { } while (0); + do { } while (0); + size_t pos = aP - begin(); + do { } while (0); + size_t oldLength = mLength; + if (pos == oldLength) { + if (!append(Forward(aVal))) { + return nullptr; + } + } else { + T oldBack = Move(back()); + if (!append(Move(oldBack))) { + return nullptr; + } + for (size_t i = oldLength - 1; i > pos; --i) { + (*this)[i] = Move((*this)[i - 1]); + } + (*this)[pos] = Forward(aVal); + } + return begin() + pos; +} + +template +inline void +Vector::erase(T* aIt) +{ + do { } while (0); + do { } while (0); + while (aIt + 1 < end()) { + *aIt = Move(*(aIt + 1)); + ++aIt; + } + popBack(); +} + +template +inline void +Vector::erase(T* aBegin, T* aEnd) +{ + do { } while (0); + do { } while (0); + do { } while (0); + while (aEnd < end()) { + *aBegin++ = Move(*aEnd++); + } + shrinkBy(aEnd - aBegin); +} + +template +template +__attribute__((always_inline)) inline bool +Vector::append(const U* aInsBegin, const U* aInsEnd) +{ + ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0); + size_t aNeeded = PointerRangeSize(aInsBegin, aInsEnd); + if (mLength + aNeeded > mTail.mCapacity) { + if ((__builtin_expect(!!(!growStorageBy(aNeeded)), 0))) { + return false; + } + } else if (!maybeCheckSimulatedOOM(mLength + aNeeded)) { + return false; + } + + + + + + internalAppend(aInsBegin, aNeeded); + return true; +} + +template +template +__attribute__((always_inline)) inline void +Vector::internalAppend(const U* aInsBegin, size_t aInsLength) +{ + do { } while (0); + do { } while (0); + Impl::copyConstruct(endNoCheck(), aInsBegin, aInsBegin + aInsLength); + mLength += aInsLength; +} + +template +template +__attribute__((always_inline)) inline bool +Vector::append(U&& aU) +{ + ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0); + if (mLength == mTail.mCapacity) { + if ((__builtin_expect(!!(!growStorageBy(1)), 0))) { + return false; + } + } else if (!maybeCheckSimulatedOOM(mLength + 1)) { + return false; + } + + + + + + internalAppend(Forward(aU)); + return true; +} + +template +template +__attribute__((always_inline)) inline bool +Vector::appendAll(const Vector& aOther) +{ + return append(aOther.begin(), aOther.length()); +} + +template +template +__attribute__((always_inline)) inline bool +Vector::append(const U* aInsBegin, size_t aInsLength) +{ + return append(aInsBegin, aInsBegin + aInsLength); +} + +template +__attribute__((always_inline)) inline void +Vector::popBack() +{ + ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0); + do { } while (0); + --mLength; + endNoCheck()->~T(); +} + +template +__attribute__((always_inline)) inline T +Vector::popCopy() +{ + T ret = back(); + popBack(); + return ret; +} + +template +inline T* +Vector::extractRawBuffer() +{ + ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0); + + if (usingInlineStorage()) { + return nullptr; + } + + T* ret = mBegin; + mBegin = inlineStorage(); + mLength = 0; + mTail.mCapacity = kInlineCapacity; + + + + return ret; +} + +template +inline T* +Vector::extractOrCopyRawBuffer() +{ + if (T* ret = extractRawBuffer()) { + return ret; + } + + ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0); + + T* copy = this->template pod_malloc(mLength); + if (!copy) { + return nullptr; + } + + Impl::moveConstruct(copy, beginNoCheck(), endNoCheck()); + Impl::destroy(beginNoCheck(), endNoCheck()); + mBegin = inlineStorage(); + mLength = 0; + mTail.mCapacity = kInlineCapacity; + + + + return copy; +} + +template +inline void +Vector::replaceRawBuffer(T* aP, size_t aLength) +{ + ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0); + + + Impl::destroy(beginNoCheck(), endNoCheck()); + if (!usingInlineStorage()) { + this->free_(beginNoCheck()); + } + + + if (aLength <= kInlineCapacity) { + + + + + + mBegin = inlineStorage(); + mLength = aLength; + mTail.mCapacity = kInlineCapacity; + Impl::moveConstruct(mBegin, aP, aP + aLength); + Impl::destroy(aP, aP + aLength); + this->free_(aP); + } else { + mBegin = aP; + mLength = aLength; + mTail.mCapacity = aLength; + } + + + +} + +template +inline size_t +Vector::sizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const +{ + return usingInlineStorage() ? 0 : aMallocSizeOf(beginNoCheck()); +} + +template +inline size_t +Vector::sizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const +{ + return aMallocSizeOf(this) + sizeOfExcludingThis(aMallocSizeOf); +} + +template +inline void +Vector::swap(Vector& aOther) +{ + static_assert(N == 0, + "still need to implement this for N != 0"); + + + if (!usingInlineStorage() && aOther.usingInlineStorage()) { + aOther.mBegin = mBegin; + mBegin = inlineStorage(); + } else if (usingInlineStorage() && !aOther.usingInlineStorage()) { + mBegin = aOther.mBegin; + aOther.mBegin = aOther.inlineStorage(); + } else if (!usingInlineStorage() && !aOther.usingInlineStorage()) { + Swap(mBegin, aOther.mBegin); + } else { + + } + + Swap(mLength, aOther.mLength); + Swap(mTail.mCapacity, aOther.mTail.mCapacity); + + + +} + +} +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" 2 + + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/UniquePtr.h" 1 +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/UniquePtr.h" +namespace js { + + +template > +using UniquePtr = mozilla::UniquePtr; + +namespace detail { + +template +struct UniqueSelector +{ + typedef UniquePtr SingleObject; +}; + +template +struct UniqueSelector +{ + typedef UniquePtr UnknownBound; +}; + +template +struct UniqueSelector +{ + typedef UniquePtr KnownBound; +}; + +} + + + +template +typename detail::UniqueSelector::SingleObject +MakeUnique(Args&&... aArgs) +{ + return UniquePtr(js_new(mozilla::Forward(aArgs)...)); +} + +template +typename detail::UniqueSelector::UnknownBound +MakeUnique(decltype(sizeof(int)) aN) = delete; + +template +typename detail::UniqueSelector::KnownBound +MakeUnique(Args&&... aArgs) = delete; + +} +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" 2 + +namespace js { +namespace gc { +class GCRuntime; +} +namespace gcstats { +struct Statistics; +} +} + +typedef enum JSGCMode { + + JSGC_MODE_GLOBAL = 0, + + + JSGC_MODE_ZONE = 1, + + + + + + JSGC_MODE_INCREMENTAL = 2 +} JSGCMode; + + + + +typedef enum JSGCInvocationKind { + + GC_NORMAL = 0, + + + GC_SHRINK = 1 +} JSGCInvocationKind; + +namespace JS { +# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" +namespace gcreason { + + +enum Reason { + + API, EAGER_ALLOC_TRIGGER, DESTROY_RUNTIME, UNUSED0, LAST_DITCH, TOO_MUCH_MALLOC, ALLOC_TRIGGER, DEBUG_GC, COMPARTMENT_REVIVED, RESET, OUT_OF_NURSERY, EVICT_NURSERY, FULL_STORE_BUFFER, SHARED_MEMORY_LIMIT, UNUSED1, INCREMENTAL_TOO_SLOW, ABORT_GC, RESERVED0, RESERVED1, RESERVED2, RESERVED3, RESERVED4, RESERVED5, RESERVED6, RESERVED7, RESERVED8, RESERVED9, RESERVED10, RESERVED11, RESERVED12, RESERVED13, RESERVED14, RESERVED15, DOM_WINDOW_UTILS, COMPONENT_UTILS, MEM_PRESSURE, CC_WAITING, CC_FORCED, LOAD_END, POST_COMPARTMENT, PAGE_HIDE, NSJSCONTEXT_DESTROY, SET_NEW_DOCUMENT, SET_DOC_SHELL, DOM_UTILS, DOM_IPC, DOM_WORKER, INTER_SLICE_GC, REFRESH_FRAME, FULL_GC_TIMER, SHUTDOWN_CC, FINISH_LARGE_EVALUATE, USER_INACTIVE, XPCONNECT_SHUTDOWN, + + NO_REASON, + NUM_REASONS, + + + + + + + + NUM_TELEMETRY_REASONS = 100 +}; + + + + +extern const char* +ExplainReason(JS::gcreason::Reason reason); + +} +# 158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" +extern void +PrepareZoneForGC(Zone* zone); + + + + +extern void +PrepareForFullGC(JSContext* cx); + + + + + + +extern void +PrepareForIncrementalGC(JSContext* cx); + + + + + +extern bool +IsGCScheduled(JSContext* cx); + + + + + +extern void +SkipZoneForGC(Zone* zone); +# 204 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" +extern void +GCForReason(JSContext* cx, JSGCInvocationKind gckind, gcreason::Reason reason); +# 236 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" +extern void +StartIncrementalGC(JSContext* cx, JSGCInvocationKind gckind, gcreason::Reason reason, + int64_t millis = 0); +# 248 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" +extern void +IncrementalGCSlice(JSContext* cx, gcreason::Reason reason, int64_t millis = 0); + + + + + + + +extern void +FinishIncrementalGC(JSContext* cx, gcreason::Reason reason); + + + + + + + +extern void +AbortIncrementalGC(JSContext* cx); + +namespace dbg { + + + + +class GarbageCollectionEvent +{ + + uint64_t majorGCNumber_; + + + + const char* reason; + + + + + const char* nonincrementalReason; + + + + struct Collection { + mozilla::TimeStamp startTimestamp; + mozilla::TimeStamp endTimestamp; + }; + + + mozilla::Vector collections; + + GarbageCollectionEvent(const GarbageCollectionEvent& rhs) = delete; + GarbageCollectionEvent& operator=(const GarbageCollectionEvent& rhs) = delete; + + public: + explicit GarbageCollectionEvent(uint64_t majorGCNum) + : majorGCNumber_(majorGCNum) + , reason(nullptr) + , nonincrementalReason(nullptr) + , collections() + { } + + using Ptr = js::UniquePtr; + static Ptr Create(JSRuntime* rt, ::js::gcstats::Statistics& stats, uint64_t majorGCNumber); + + JSObject* toJSObject(JSContext* cx) const; + + uint64_t majorGCNumber() const { return majorGCNumber_; } +}; + +} + +enum GCProgress { +# 330 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" + GC_CYCLE_BEGIN, + GC_SLICE_BEGIN, + GC_SLICE_END, + GC_CYCLE_END +}; + +struct GCDescription { + bool isZone_; + JSGCInvocationKind invocationKind_; + gcreason::Reason reason_; + + GCDescription(bool isZone, JSGCInvocationKind kind, gcreason::Reason reason) + : isZone_(isZone), invocationKind_(kind), reason_(reason) {} + + char16_t* formatSliceMessage(JSContext* cx) const; + char16_t* formatSummaryMessage(JSContext* cx) const; + char16_t* formatJSON(JSContext* cx, uint64_t timestamp) const; + + JS::dbg::GarbageCollectionEvent::Ptr toGCEvent(JSContext* cx) const; +}; + +typedef void +(* GCSliceCallback)(JSContext* cx, GCProgress progress, const GCDescription& desc); + + + + + + +extern GCSliceCallback +SetGCSliceCallback(JSContext* cx, GCSliceCallback callback); + + + + +enum class GCNurseryProgress { + + + + GC_NURSERY_COLLECTION_START, + + + + GC_NURSERY_COLLECTION_END +}; + + + + + +using GCNurseryCollectionCallback = void(*)(JSContext* cx, GCNurseryProgress progress, + gcreason::Reason reason); + + + + + +extern GCNurseryCollectionCallback +SetGCNurseryCollectionCallback(JSContext* cx, GCNurseryCollectionCallback callback); + +typedef void +(* DoCycleCollectionCallback)(JSContext* cx); + + + + + +extern DoCycleCollectionCallback +SetDoCycleCollectionCallback(JSContext* cx, DoCycleCollectionCallback callback); + + + + + + + +extern void +DisableIncrementalGC(JSContext* cx); +# 417 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" +extern bool +IsIncrementalGCEnabled(JSContext* cx); + + + + + +extern bool +IsIncrementalGCInProgress(JSContext* cx); + + + + + + + +extern bool +IsIncrementalBarrierNeeded(JSContext* cx); + + + + + +extern void +IncrementalPreWriteBarrier(JSObject* obj); + + + + + +extern void +IncrementalReadBarrier(GCCellPtr thing); + + + + +extern bool +WasIncrementalGC(JSContext* cx); +# 465 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" +class AutoDisableGenerationalGC +{ + JSContext* cx; + + public: + explicit AutoDisableGenerationalGC(JSContext* cx); + ~AutoDisableGenerationalGC(); +}; + + + + + +extern bool +IsGenerationalGCEnabled(JSRuntime* rt); + + + + + + +extern size_t +GetGCNumber(); + + + + + + +class AutoRequireNoGC +{ + protected: + AutoRequireNoGC() {} + ~AutoRequireNoGC() {} +}; +# 509 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" +class AutoAssertNoGC : public AutoRequireNoGC +{ + JSContext* cx_; + + public: + explicit AutoAssertNoGC(JSContext* cx = nullptr); + ~AutoAssertNoGC(); +}; + + + + + +class AutoAssertNoAlloc +{ + + js::gc::GCRuntime* gc; + + public: + AutoAssertNoAlloc() : gc(nullptr) {} + explicit AutoAssertNoAlloc(JSContext* cx); + void disallowAlloc(JSRuntime* rt); + ~AutoAssertNoAlloc(); + + + + + + +}; + + + + + +class AutoAssertOnBarrier +{ + JSContext* context; + bool prev; + + public: + explicit AutoAssertOnBarrier(JSContext* cx); + ~AutoAssertOnBarrier(); +}; +# 568 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" +class AutoSuppressGCAnalysis : public AutoAssertNoAlloc +{ + public: + AutoSuppressGCAnalysis() : AutoAssertNoAlloc() {} + explicit AutoSuppressGCAnalysis(JSContext* cx) : AutoAssertNoAlloc(cx) {} +} ; +# 583 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" +class AutoAssertGCCallback : public AutoSuppressGCAnalysis +{ + public: + explicit AutoAssertGCCallback(JSObject* obj); +}; +# 608 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" +class AutoCheckCannotGC : public AutoRequireNoGC +{ + public: + explicit AutoCheckCannotGC(JSContext* cx = nullptr) {} +} ; + + + + + + + +extern bool +UnmarkGrayGCThingRecursively(GCCellPtr thing); + +} + +namespace js { +namespace gc { + +extern bool +BarriersAreAllowedOnCurrentThread(); + +static __attribute__((always_inline)) inline void +ExposeGCThingToActiveJS(JS::GCCellPtr thing) +{ + + + + if (IsInsideNursery(thing.asCell())) + return; + + + + if (thing.mayBeOwnedByOtherRuntime()) + return; + + do { static_assert(mozilla::detail::AssertionConditionType::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(BarriersAreAllowedOnCurrentThread()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "BarriersAreAllowedOnCurrentThread()" ")"); do { *((volatile int*) __null) = 645; ::abort(); } while (0); } } while (0); + + if (IsIncrementalBarrierNeededOnTenuredGCThing(thing)) + JS::IncrementalReadBarrier(thing); + else if (js::gc::detail::CellIsMarkedGray(thing.asCell())) + JS::UnmarkGrayGCThingRecursively(thing); + + do { } while (0); +} + +static __attribute__((always_inline)) inline void +GCThingReadBarrier(JS::GCCellPtr thing) +{ + + + if (IsInsideNursery(thing.asCell())) + return; + + + + if (thing.mayBeOwnedByOtherRuntime()) + return; + + do { static_assert(mozilla::detail::AssertionConditionType::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(BarriersAreAllowedOnCurrentThread()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "BarriersAreAllowedOnCurrentThread()" ")"); do { *((volatile int*) __null) = 668; ::abort(); } while (0); } } while (0); + + if (IsIncrementalBarrierNeededOnTenuredGCThing(thing)) + JS::IncrementalReadBarrier(thing); +} + +} +} + +namespace JS { + + + + + + + +static __attribute__((always_inline)) inline void +ExposeObjectToActiveJS(JSObject* obj) +{ + do { } while (0); + js::gc::ExposeGCThingToActiveJS(GCCellPtr(obj)); +} + +static __attribute__((always_inline)) inline void +ExposeScriptToActiveJS(JSScript* script) +{ + js::gc::ExposeGCThingToActiveJS(GCCellPtr(script)); +} + + + + +static __attribute__((always_inline)) inline void +StringReadBarrier(JSString* string) +{ + do { } while (0); + js::gc::GCThingReadBarrier(GCCellPtr(string)); +} + + + + + + +extern void +PokeGC(JSContext* cx); + + + + +extern void +NotifyDidPaint(JSContext* cx); + +} +# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCPolicyAPI.h" 1 +# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCPolicyAPI.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsalloc.h" 1 +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsalloc.h" +namespace js { + +enum class AllocFunction { + Malloc, + Calloc, + Realloc +}; + + +class SystemAllocPolicy +{ + public: + template T* maybe_pod_malloc(size_t numElems) { return js_pod_malloc(numElems); } + template T* maybe_pod_calloc(size_t numElems) { return js_pod_calloc(numElems); } + template T* maybe_pod_realloc(T* p, size_t oldSize, size_t newSize) { + return js_pod_realloc(p, oldSize, newSize); + } + template T* pod_malloc(size_t numElems) { return maybe_pod_malloc(numElems); } + template T* pod_calloc(size_t numElems) { return maybe_pod_calloc(numElems); } + template T* pod_realloc(T* p, size_t oldSize, size_t newSize) { + return maybe_pod_realloc(p, oldSize, newSize); + } + void free_(void* p) { js_free(p); } + void reportAllocOverflow() const {} + bool checkSimulatedOOM() const { + return !js::oom::ShouldFailWithOOM(); + } +}; + +void ReportOutOfMemory(JSContext* cx); +# 60 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsalloc.h" +class TempAllocPolicy +{ + JSContext* const cx_; + + + + + + void* onOutOfMemory(AllocFunction allocFunc, size_t nbytes, + void* reallocPtr = nullptr); + + template + T* onOutOfMemoryTyped(AllocFunction allocFunc, size_t numElems, void* reallocPtr = nullptr) { + size_t bytes; + if ((__builtin_expect(!!(!CalculateAllocSize(numElems, &bytes)), 0))) + return nullptr; + return static_cast(onOutOfMemory(allocFunc, bytes, reallocPtr)); + } + + public: + TempAllocPolicy(JSContext* cx) : cx_(cx) {} + + template + T* maybe_pod_malloc(size_t numElems) { + return js_pod_malloc(numElems); + } + + template + T* maybe_pod_calloc(size_t numElems) { + return js_pod_calloc(numElems); + } + + template + T* maybe_pod_realloc(T* prior, size_t oldSize, size_t newSize) { + return js_pod_realloc(prior, oldSize, newSize); + } + + template + T* pod_malloc(size_t numElems) { + T* p = maybe_pod_malloc(numElems); + if ((__builtin_expect(!!(!p), 0))) + p = onOutOfMemoryTyped(AllocFunction::Malloc, numElems); + return p; + } + + template + T* pod_calloc(size_t numElems) { + T* p = maybe_pod_calloc(numElems); + if ((__builtin_expect(!!(!p), 0))) + p = onOutOfMemoryTyped(AllocFunction::Calloc, numElems); + return p; + } + + template + T* pod_realloc(T* prior, size_t oldSize, size_t newSize) { + T* p2 = maybe_pod_realloc(prior, oldSize, newSize); + if ((__builtin_expect(!!(!p2), 0))) + p2 = onOutOfMemoryTyped(AllocFunction::Realloc, newSize, prior); + return p2; + } + + void free_(void* p) { + js_free(p); + } + + void reportAllocOverflow() const; + + bool checkSimulatedOOM() const { + if (js::oom::ShouldFailWithOOM()) { + ReportOutOfMemory(cx_); + return false; + } + + return true; + } +}; + +} +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h" 2 + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" 1 +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h" 1 +# 59 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h" +namespace mozilla { + + + + +static const uint32_t kGoldenRatioU32 = 0x9E3779B9U; + +inline uint32_t +RotateBitsLeft32(uint32_t aValue, uint8_t aBits) +{ + do { } while (0); + return (aValue << aBits) | (aValue >> (32 - aBits)); +} + +namespace detail { + +inline uint32_t +AddU32ToHash(uint32_t aHash, uint32_t aValue) +{ +# 117 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h" + return kGoldenRatioU32 * (RotateBitsLeft32(aHash, 5) ^ aValue); +} + + + + +template +inline uint32_t +AddUintptrToHash(uint32_t aHash, uintptr_t aValue); + +template<> +inline uint32_t +AddUintptrToHash<4>(uint32_t aHash, uintptr_t aValue) +{ + return AddU32ToHash(aHash, static_cast(aValue)); +} + +template<> +inline uint32_t +AddUintptrToHash<8>(uint32_t aHash, uintptr_t aValue) +{ + + + + + + + + uint32_t v1 = static_cast(aValue); + uint32_t v2 = static_cast(static_cast(aValue) >> 32); + return AddU32ToHash(AddU32ToHash(aHash, v1), v2); +} + +} +# 159 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h" +template +__attribute__ ((warn_unused_result)) inline uint32_t +AddToHash(uint32_t aHash, A aA) +{ + + + + + return detail::AddU32ToHash(aHash, aA); +} + +template +__attribute__ ((warn_unused_result)) inline uint32_t +AddToHash(uint32_t aHash, A* aA) +{ + + + + + + static_assert(sizeof(aA) == sizeof(uintptr_t), "Strange pointer!"); + + return detail::AddUintptrToHash(aHash, uintptr_t(aA)); +} + +template<> +__attribute__ ((warn_unused_result)) inline uint32_t +AddToHash(uint32_t aHash, uintptr_t aA) +{ + return detail::AddUintptrToHash(aHash, aA); +} + +template +__attribute__ ((warn_unused_result)) uint32_t +AddToHash(uint32_t aHash, A aArg, Args... aArgs) +{ + return AddToHash(AddToHash(aHash, aArg), aArgs...); +} +# 205 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h" +template +__attribute__ ((warn_unused_result)) inline uint32_t +HashGeneric(Args... aArgs) +{ + return AddToHash(0, aArgs...); +} + +namespace detail { + +template +uint32_t +HashUntilZero(const T* aStr) +{ + uint32_t hash = 0; + for (T c; (c = *aStr); aStr++) { + hash = AddToHash(hash, c); + } + return hash; +} + +template +uint32_t +HashKnownLength(const T* aStr, size_t aLength) +{ + uint32_t hash = 0; + for (size_t i = 0; i < aLength; i++) { + hash = AddToHash(hash, aStr[i]); + } + return hash; +} + +} + + + + + + + +__attribute__ ((warn_unused_result)) inline uint32_t +HashString(const char* aStr) +{ + return detail::HashUntilZero(reinterpret_cast(aStr)); +} + +__attribute__ ((warn_unused_result)) inline uint32_t +HashString(const char* aStr, size_t aLength) +{ + return detail::HashKnownLength(reinterpret_cast(aStr), aLength); +} + +__attribute__ ((warn_unused_result)) +inline uint32_t +HashString(const unsigned char* aStr, size_t aLength) +{ + return detail::HashKnownLength(aStr, aLength); +} + +__attribute__ ((warn_unused_result)) inline uint32_t +HashString(const char16_t* aStr) +{ + return detail::HashUntilZero(aStr); +} + +__attribute__ ((warn_unused_result)) inline uint32_t +HashString(const char16_t* aStr, size_t aLength) +{ + return detail::HashKnownLength(aStr, aLength); +} +# 299 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h" +__attribute__ ((warn_unused_result)) extern __attribute__((weak)) __attribute__((visibility("default"))) uint32_t +HashBytes(const void* bytes, size_t aLength); +# 318 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h" +class HashCodeScrambler +{ + struct SipHasher; + + uint64_t mK0, mK1; + +public: + + constexpr HashCodeScrambler(uint64_t aK0, uint64_t aK1) : mK0(aK0), mK1(aK1) {} + + + + + + uint32_t scramble(uint32_t aHashCode) const + { + SipHasher hasher(mK0, mK1); + return uint32_t(hasher.sipHash(aHashCode)); + } + +private: + struct SipHasher + { + SipHasher(uint64_t aK0, uint64_t aK1) + { + + mV0 = aK0 ^ 0x736f6d6570736575UL; + mV1 = aK1 ^ 0x646f72616e646f6dUL; + mV2 = aK0 ^ 0x6c7967656e657261UL; + mV3 = aK1 ^ 0x7465646279746573UL; + } + + uint64_t sipHash(uint64_t aM) + { + + mV3 ^= aM; + sipRound(); + mV0 ^= aM; + + + mV2 ^= 0xff; + for (int i = 0; i < 3; i++) + sipRound(); + return mV0 ^ mV1 ^ mV2 ^ mV3; + } + + void sipRound() + { + mV0 += mV1; + mV1 = RotateLeft(mV1, 13); + mV1 ^= mV0; + mV0 = RotateLeft(mV0, 32); + mV2 += mV3; + mV3 = RotateLeft(mV3, 16); + mV3 ^= mV2; + mV0 += mV3; + mV3 = RotateLeft(mV3, 21); + mV3 ^= mV0; + mV2 += mV1; + mV1 = RotateLeft(mV1, 17); + mV1 ^= mV2; + mV2 = RotateLeft(mV2, 32); + } + + uint64_t mV0, mV1, mV2, mV3; + }; +}; + +} +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" 2 + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Opaque.h" 1 +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Opaque.h" +namespace mozilla { + + + + + + +template +class Opaque final +{ + static_assert(mozilla::IsIntegral::value, + "mozilla::Opaque only supports integral types"); + + T mValue; + +public: + Opaque() {} + explicit Opaque(T aValue) : mValue(aValue) {} + + bool operator==(const Opaque& aOther) const { + return mValue == aOther.mValue; + } + + bool operator!=(const Opaque& aOther) const { + return !(*this == aOther); + } +}; + +} +# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" 2 + + + + + + + + +namespace js { + +class TempAllocPolicy; +template struct DefaultHasher; +template class HashMapEntry; +namespace detail { + template class HashTableEntry; + template class HashTable; +} +# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" +using Generation = mozilla::Opaque; +# 65 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" +template , + class AllocPolicy = TempAllocPolicy> +class HashMap +{ + typedef HashMapEntry TableEntry; + + struct MapHashPolicy : HashPolicy + { + using Base = HashPolicy; + typedef Key KeyType; + static const Key& getKey(TableEntry& e) { return e.key(); } + static void setKey(TableEntry& e, Key& k) { HashPolicy::rekey(e.mutableKey(), k); } + }; + + typedef detail::HashTable Impl; + Impl impl; + + public: + typedef typename HashPolicy::Lookup Lookup; + typedef TableEntry Entry; + + + + explicit HashMap(AllocPolicy a = AllocPolicy()) : impl(a) {} + __attribute__ ((warn_unused_result)) bool init(uint32_t len = 16) { return impl.init(len); } + bool initialized() const { return impl.initialized(); } +# 105 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" + typedef typename Impl::Ptr Ptr; + __attribute__((always_inline)) inline Ptr lookup(const Lookup& l) const { return impl.lookup(l); } + + + + __attribute__((always_inline)) inline Ptr readonlyThreadsafeLookup(const Lookup& l) const { + return impl.readonlyThreadsafeLookup(l); + } + + + void remove(Ptr p) { impl.remove(p); } +# 150 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" + typedef typename Impl::AddPtr AddPtr; + __attribute__((always_inline)) inline AddPtr lookupForAdd(const Lookup& l) const { + return impl.lookupForAdd(l); + } + + template + __attribute__ ((warn_unused_result)) bool add(AddPtr& p, KeyInput&& k, ValueInput&& v) { + return impl.add(p, + mozilla::Forward(k), + mozilla::Forward(v)); + } + + template + __attribute__ ((warn_unused_result)) bool add(AddPtr& p, KeyInput&& k) { + return impl.add(p, mozilla::Forward(k), Value()); + } + + template + __attribute__ ((warn_unused_result)) bool relookupOrAdd(AddPtr& p, KeyInput&& k, ValueInput&& v) { + return impl.relookupOrAdd(p, k, + mozilla::Forward(k), + mozilla::Forward(v)); + } +# 182 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" + typedef typename Impl::Range Range; + Range all() const { return impl.all(); } +# 196 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" + typedef typename Impl::Enum Enum; + + + + void clear() { impl.clear(); } + + + + void clearAndShrink() { impl.clearAndShrink(); } + + + + void finish() { impl.finish(); } + + + bool empty() const { return impl.empty(); } + + + uint32_t count() const { return impl.count(); } + + + + size_t capacity() const { return impl.capacity(); } + + + + size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const { + return impl.sizeOfExcludingThis(mallocSizeOf); + } + size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const { + return mallocSizeOf(this) + impl.sizeOfExcludingThis(mallocSizeOf); + } + + Generation generation() const { + return impl.generation(); + } + + + + bool has(const Lookup& l) const { + return impl.lookup(l).found(); + } + + + template + __attribute__ ((warn_unused_result)) bool put(KeyInput&& k, ValueInput&& v) { + AddPtr p = lookupForAdd(k); + if (p) { + p->value() = mozilla::Forward(v); + return true; + } + return add(p, mozilla::Forward(k), mozilla::Forward(v)); + } + + + template + __attribute__ ((warn_unused_result)) bool putNew(KeyInput&& k, ValueInput&& v) { + return impl.putNew(k, mozilla::Forward(k), mozilla::Forward(v)); + } + + + template + void putNewInfallible(KeyInput&& k, ValueInput&& v) { + impl.putNewInfallible(k, mozilla::Forward(k), mozilla::Forward(v)); + } + + + Ptr lookupWithDefault(const Key& k, const Value& defaultValue) { + AddPtr p = lookupForAdd(k); + if (p) + return p; + bool ok = add(p, k, defaultValue); + do { } while (0); + (void)ok; + return p; + } + + + void remove(const Lookup& l) { + if (Ptr p = lookup(l)) + remove(p); + } + + + + void rekeyIfMoved(const Key& old_key, const Key& new_key) { + if (old_key != new_key) + rekeyAs(old_key, new_key, new_key); + } + + + bool rekeyAs(const Lookup& old_lookup, const Lookup& new_lookup, const Key& new_key) { + if (Ptr p = lookup(old_lookup)) { + impl.rekeyAndMaybeRehash(p, new_lookup, new_key); + return true; + } + return false; + } + + + HashMap(HashMap&& rhs) : impl(mozilla::Move(rhs.impl)) {} + void operator=(HashMap&& rhs) { + do { } while (0); + impl = mozilla::Move(rhs.impl); + } + + private: + + HashMap(const HashMap& hm) = delete; + HashMap& operator=(const HashMap& hm) = delete; + + friend class Impl::Enum; +}; +# 327 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" +template , + class AllocPolicy = TempAllocPolicy> +class HashSet +{ + struct SetOps : HashPolicy + { + using Base = HashPolicy; + typedef T KeyType; + static const KeyType& getKey(const T& t) { return t; } + static void setKey(T& t, KeyType& k) { HashPolicy::rekey(t, k); } + }; + + typedef detail::HashTable Impl; + Impl impl; + + public: + typedef typename HashPolicy::Lookup Lookup; + typedef T Entry; + + + + explicit HashSet(AllocPolicy a = AllocPolicy()) : impl(a) {} + __attribute__ ((warn_unused_result)) bool init(uint32_t len = 16) { return impl.init(len); } + bool initialized() const { return impl.initialized(); } +# 362 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" + typedef typename Impl::Ptr Ptr; + __attribute__((always_inline)) inline Ptr lookup(const Lookup& l) const { return impl.lookup(l); } + + + + __attribute__((always_inline)) inline Ptr readonlyThreadsafeLookup(const Lookup& l) const { + return impl.readonlyThreadsafeLookup(l); + } + + + void remove(Ptr p) { impl.remove(p); } +# 406 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" + typedef typename Impl::AddPtr AddPtr; + __attribute__((always_inline)) inline AddPtr lookupForAdd(const Lookup& l) const { + return impl.lookupForAdd(l); + } + + template + __attribute__ ((warn_unused_result)) bool add(AddPtr& p, U&& u) { + return impl.add(p, mozilla::Forward(u)); + } + + template + __attribute__ ((warn_unused_result)) bool relookupOrAdd(AddPtr& p, const Lookup& l, U&& u) { + return impl.relookupOrAdd(p, l, mozilla::Forward(u)); + } +# 429 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" + typedef typename Impl::Range Range; + Range all() const { return impl.all(); } +# 443 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" + typedef typename Impl::Enum Enum; + + + + void clear() { impl.clear(); } + + + + void clearAndShrink() { impl.clearAndShrink(); } + + + + void finish() { impl.finish(); } + + + bool empty() const { return impl.empty(); } + + + uint32_t count() const { return impl.count(); } + + + + size_t capacity() const { return impl.capacity(); } + + + + size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const { + return impl.sizeOfExcludingThis(mallocSizeOf); + } + size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const { + return mallocSizeOf(this) + impl.sizeOfExcludingThis(mallocSizeOf); + } + + Generation generation() const { + return impl.generation(); + } + + + + bool has(const Lookup& l) const { + return impl.lookup(l).found(); + } + + + template + __attribute__ ((warn_unused_result)) bool put(U&& u) { + AddPtr p = lookupForAdd(u); + return p ? true : add(p, mozilla::Forward(u)); + } + + + template + __attribute__ ((warn_unused_result)) bool putNew(U&& u) { + return impl.putNew(u, mozilla::Forward(u)); + } + + template + __attribute__ ((warn_unused_result)) bool putNew(const Lookup& l, U&& u) { + return impl.putNew(l, mozilla::Forward(u)); + } + + + template + void putNewInfallible(const Lookup& l, U&& u) { + impl.putNewInfallible(l, mozilla::Forward(u)); + } + + void remove(const Lookup& l) { + if (Ptr p = lookup(l)) + remove(p); + } + + + + void rekeyIfMoved(const Lookup& old_value, const T& new_value) { + if (old_value != new_value) + rekeyAs(old_value, new_value, new_value); + } + + + bool rekeyAs(const Lookup& old_lookup, const Lookup& new_lookup, const T& new_value) { + if (Ptr p = lookup(old_lookup)) { + impl.rekeyAndMaybeRehash(p, new_lookup, new_value); + return true; + } + return false; + } + + + + + + void replaceKey(Ptr p, const T& new_value) { + do { } while (0); + do { } while (0); + do { } while (0); + do { } while (0); + const_cast(*p) = new_value; + } + + + HashSet(HashSet&& rhs) : impl(mozilla::Move(rhs.impl)) {} + void operator=(HashSet&& rhs) { + do { } while (0); + impl = mozilla::Move(rhs.impl); + } + + private: + + HashSet(const HashSet& hs) = delete; + HashSet& operator=(const HashSet& hs) = delete; + + friend class Impl::Enum; +}; +# 587 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" +template +struct PointerHasher +{ + typedef Key Lookup; + static HashNumber hash(const Lookup& l) { + size_t word = reinterpret_cast(l) >> zeroBits; + static_assert(sizeof(HashNumber) == 4, + "subsequent code assumes a four-byte hash"); + + + + static_assert(sizeof(word) == 8, + "unexpected word size, new hashing strategy required to " + "properly incorporate all bits"); + return HashNumber((word >> 32) ^ word); + + } + static bool match(const Key& k, const Lookup& l) { + return k == l; + } + static void rekey(Key& k, const Key& newKey) { + k = newKey; + } +}; + + + + + +template +struct DefaultHasher +{ + typedef Key Lookup; + static HashNumber hash(const Lookup& l) { + + return l; + } + static bool match(const Key& k, const Lookup& l) { + + return k == l; + } + static void rekey(Key& k, const Key& newKey) { + k = newKey; + } +}; + + + +template +struct DefaultHasher : PointerHasher::value> +{}; + + + +template +struct DefaultHasher> +{ + using Lookup = mozilla::UniquePtr; + using PtrHasher = PointerHasher::value>; + + static HashNumber hash(const Lookup& l) { + return PtrHasher::hash(l.get()); + } + static bool match(const mozilla::UniquePtr& k, const Lookup& l) { + return PtrHasher::match(k.get(), l.get()); + } + static void rekey(mozilla::UniquePtr& k, mozilla::UniquePtr&& newKey) { + k = mozilla::Move(newKey); + } +}; + + +template <> +struct DefaultHasher +{ + typedef double Lookup; + static HashNumber hash(double d) { + static_assert(sizeof(HashNumber) == 4, + "subsequent code assumes a four-byte hash"); + uint64_t u = mozilla::BitwiseCast(d); + return HashNumber(u ^ (u >> 32)); + } + static bool match(double lhs, double rhs) { + return mozilla::BitwiseCast(lhs) == mozilla::BitwiseCast(rhs); + } +}; + +template <> +struct DefaultHasher +{ + typedef float Lookup; + static HashNumber hash(float f) { + static_assert(sizeof(HashNumber) == 4, + "subsequent code assumes a four-byte hash"); + return HashNumber(mozilla::BitwiseCast(f)); + } + static bool match(float lhs, float rhs) { + return mozilla::BitwiseCast(lhs) == mozilla::BitwiseCast(rhs); + } +}; + + +struct CStringHasher +{ + typedef const char* Lookup; + static js::HashNumber hash(Lookup l) { + return mozilla::HashString(l); + } + static bool match(const char* key, Lookup lookup) { + return strcmp(key, lookup) == 0; + } +}; +# 708 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" +template +struct FallibleHashMethods +{ + + + template static bool hasHash(Lookup&& l) { return true; } + + + + template static bool ensureHash(Lookup&& l) { return true; } +}; + +template +static bool +HasHash(Lookup&& l) { + return FallibleHashMethods::hasHash(mozilla::Forward(l)); +} + +template +static bool +EnsureHash(Lookup&& l) { + return FallibleHashMethods::ensureHash(mozilla::Forward(l)); +} +# 739 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" +template +class HashMapEntry +{ + Key key_; + Value value_; + + template friend class detail::HashTable; + template friend class detail::HashTableEntry; + template friend class HashMap; + + public: + template + HashMapEntry(KeyInput&& k, ValueInput&& v) + : key_(mozilla::Forward(k)), + value_(mozilla::Forward(v)) + {} + + HashMapEntry(HashMapEntry&& rhs) + : key_(mozilla::Move(rhs.key_)), + value_(mozilla::Move(rhs.value_)) + {} + + void operator=(HashMapEntry&& rhs) { + key_ = mozilla::Move(rhs.key_); + value_ = mozilla::Move(rhs.value_); + } + + typedef Key KeyType; + typedef Value ValueType; + + const Key& key() const { return key_; } + Key& mutableKey() { return key_; } + const Value& value() const { return value_; } + Value& value() { return value_; } + + private: + HashMapEntry(const HashMapEntry&) = delete; + void operator=(const HashMapEntry&) = delete; +}; + +} + +namespace mozilla { + +template +struct IsPod > : IsPod {}; + +template +struct IsPod > + : IntegralConstant::value && IsPod::value> +{}; + +} + +namespace js { + +namespace detail { + +template +class HashTable; + +template +class HashTableEntry +{ + template friend class HashTable; + typedef typename mozilla::RemoveConst::Type NonConstT; + + HashNumber keyHash; + mozilla::AlignedStorage2 mem; + + static const HashNumber sFreeKey = 0; + static const HashNumber sRemovedKey = 1; + static const HashNumber sCollisionBit = 1; + + static bool isLiveHash(HashNumber hash) + { + return hash > sRemovedKey; + } + + HashTableEntry(const HashTableEntry&) = delete; + void operator=(const HashTableEntry&) = delete; + ~HashTableEntry() = delete; + + public: + + + void destroyIfLive() { + if (isLive()) + mem.addr()->~T(); + } + + void destroy() { + do { } while (0); + mem.addr()->~T(); + } + + void swap(HashTableEntry* other) { + if (this == other) + return; + do { } while (0); + if (other->isLive()) { + mozilla::Swap(*mem.addr(), *other->mem.addr()); + } else { + *other->mem.addr() = mozilla::Move(*mem.addr()); + destroy(); + } + mozilla::Swap(keyHash, other->keyHash); + } + + T& get() { do { } while (0); return *mem.addr(); } + NonConstT& getMutable() { do { } while (0); return *mem.addr(); } + + bool isFree() const { return keyHash == sFreeKey; } + void clearLive() { do { } while (0); keyHash = sFreeKey; mem.addr()->~T(); } + void clear() { if (isLive()) mem.addr()->~T(); keyHash = sFreeKey; } + bool isRemoved() const { return keyHash == sRemovedKey; } + void removeLive() { do { } while (0); keyHash = sRemovedKey; mem.addr()->~T(); } + bool isLive() const { return isLiveHash(keyHash); } + void setCollision() { do { } while (0); keyHash |= sCollisionBit; } + void unsetCollision() { keyHash &= ~sCollisionBit; } + bool hasCollision() const { return keyHash & sCollisionBit; } + bool matchHash(HashNumber hn) { return (keyHash & ~sCollisionBit) == hn; } + HashNumber getKeyHash() const { return keyHash & ~sCollisionBit; } + + template + void setLive(HashNumber hn, Args&&... args) + { + do { } while (0); + keyHash = hn; + new(mem.addr()) T(mozilla::Forward(args)...); + do { } while (0); + } +}; + +template +class HashTable : private AllocPolicy +{ + friend class mozilla::ReentrancyGuard; + + typedef typename mozilla::RemoveConst::Type NonConstT; + typedef typename HashPolicy::KeyType Key; + typedef typename HashPolicy::Lookup Lookup; + + public: + typedef HashTableEntry Entry; + + + + + + class Ptr + { + friend class HashTable; + + Entry* entry_; + + const HashTable* table_; + Generation generation; + + + protected: + Ptr(Entry& entry, const HashTable& tableArg) + : entry_(&entry) + + , table_(&tableArg) + , generation(tableArg.generation()) + + {} + + public: + Ptr() + : entry_(nullptr) + + , table_(nullptr) + , generation(0) + + {} + + bool isValid() const { + return !entry_; + } + + bool found() const { + if (isValid()) + return false; + + do { } while (0); + + return entry_->isLive(); + } + + explicit operator bool() const { + return found(); + } + + bool operator==(const Ptr& rhs) const { + do { } while (0); + return entry_ == rhs.entry_; + } + + bool operator!=(const Ptr& rhs) const { + + do { } while (0); + + return !(*this == rhs); + } + + T& operator*() const { + + do { } while (0); + do { } while (0); + + return entry_->get(); + } + + T* operator->() const { + + do { } while (0); + do { } while (0); + + return &entry_->get(); + } + }; + + + class AddPtr : public Ptr + { + friend class HashTable; + HashNumber keyHash; + + uint64_t mutationCount; + + + AddPtr(Entry& entry, const HashTable& tableArg, HashNumber hn) + : Ptr(entry, tableArg) + , keyHash(hn) + + , mutationCount(tableArg.mutationCount) + + {} + + public: + AddPtr() : keyHash(0) {} + }; + + + + + + class Range + { + protected: + friend class HashTable; + + Range(const HashTable& tableArg, Entry* c, Entry* e) + : cur(c) + , end(e) + + , table_(&tableArg) + , mutationCount(tableArg.mutationCount) + , generation(tableArg.generation()) + , validEntry(true) + + { + while (cur < end && !cur->isLive()) + ++cur; + } + + Entry* cur; + Entry* end; + + const HashTable* table_; + uint64_t mutationCount; + Generation generation; + bool validEntry; + + + public: + Range() + : cur(nullptr) + , end(nullptr) + + , table_(nullptr) + , mutationCount(0) + , generation(0) + , validEntry(false) + + {} + + bool empty() const { + + do { } while (0); + do { } while (0); + + return cur == end; + } + + T& front() const { + do { } while (0); + + do { } while (0); + do { } while (0); + do { } while (0); + + return cur->get(); + } + + void popFront() { + do { } while (0); + + do { } while (0); + do { } while (0); + + while (++cur < end && !cur->isLive()) + continue; + + validEntry = true; + + } + }; + + + + + + + class Enum : public Range + { + friend class HashTable; + + HashTable& table_; + bool rekeyed; + bool removed; + + + Enum(const Enum&) = delete; + void operator=(const Enum&) = delete; + + public: + template explicit + Enum(Map& map) : Range(map.all()), table_(map.impl), rekeyed(false), removed(false) {} +# 1088 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" + void removeFront() { + table_.remove(*this->cur); + removed = true; + + this->validEntry = false; + this->mutationCount = table_.mutationCount; + + } + + NonConstT& mutableFront() { + do { } while (0); + + do { } while (0); + do { } while (0); + do { } while (0); + + return this->cur->getMutable(); + } + + + + + void rekeyFront(const Lookup& l, const Key& k) { + do { } while (0); + Ptr p(*this->cur, table_); + table_.rekeyWithoutRehash(p, l, k); + rekeyed = true; + + this->validEntry = false; + this->mutationCount = table_.mutationCount; + + } + + void rekeyFront(const Key& k) { + rekeyFront(k, k); + } + + + ~Enum() { + if (rekeyed) { + table_.gen++; + table_.checkOverRemoved(); + } + + if (removed) + table_.compactIfUnderloaded(); + } + }; + + + HashTable(HashTable&& rhs) + : AllocPolicy(rhs) + { + mozilla::PodAssign(this, &rhs); + rhs.table = nullptr; + } + void operator=(HashTable&& rhs) { + do { } while (0); + if (table) + destroyTable(*this, table, capacity()); + mozilla::PodAssign(this, &rhs); + rhs.table = nullptr; + } + + private: + + HashTable(const HashTable&) = delete; + void operator=(const HashTable&) = delete; + + private: + static const size_t CAP_BITS = 30; + + public: + uint64_t gen:56; + uint64_t hashShift:8; + Entry* table; + uint32_t entryCount; + uint32_t removedCount; + + + uint64_t mutationCount; + mutable bool mEntered; + + + mutable struct Stats + { + uint32_t searches; + uint32_t steps; + uint32_t hits; + uint32_t misses; + uint32_t addOverRemoved; + uint32_t removes; + uint32_t removeFrees; + uint32_t grows; + uint32_t shrinks; + uint32_t compresses; + uint32_t rehashes; + } stats; + + + + + + + + static const unsigned sMinCapacityLog2 = 2; + static const unsigned sMinCapacity = 1 << sMinCapacityLog2; + static const unsigned sMaxInit = ((uint32_t)1 << (CAP_BITS - 1)); + static const unsigned sMaxCapacity = ((uint32_t)1 << (CAP_BITS)); + static const unsigned sHashBits = mozilla::tl::BitSize::value; + + + + static const uint8_t sAlphaDenominator = 4; + static const uint8_t sMinAlphaNumerator = 1; + static const uint8_t sMaxAlphaNumerator = 3; + + static const HashNumber sFreeKey = Entry::sFreeKey; + static const HashNumber sRemovedKey = Entry::sRemovedKey; + static const HashNumber sCollisionBit = Entry::sCollisionBit; + + void setTableSizeLog2(unsigned sizeLog2) + { + hashShift = sHashBits - sizeLog2; + } + + static bool isLiveHash(HashNumber hash) + { + return Entry::isLiveHash(hash); + } + + static HashNumber prepareHash(const Lookup& l) + { + HashNumber keyHash = ScrambleHashCode(HashPolicy::hash(l)); + + + if (!isLiveHash(keyHash)) + keyHash -= (sRemovedKey + 1); + return keyHash & ~sCollisionBit; + } + + enum FailureBehavior { DontReportFailure = false, ReportFailure = true }; + + static Entry* createTable(AllocPolicy& alloc, uint32_t capacity, + FailureBehavior reportFailure = ReportFailure) + { + static_assert(sFreeKey == 0, + "newly-calloc'd tables have to be considered empty"); + if (reportFailure) + return alloc.template pod_calloc(capacity); + + return alloc.template maybe_pod_calloc(capacity); + } + + static Entry* maybeCreateTable(AllocPolicy& alloc, uint32_t capacity) + { + static_assert(sFreeKey == 0, + "newly-calloc'd tables have to be considered empty"); + return alloc.template maybe_pod_calloc(capacity); + } + + static void destroyTable(AllocPolicy& alloc, Entry* oldTable, uint32_t capacity) + { + Entry* end = oldTable + capacity; + for (Entry* e = oldTable; e < end; ++e) + e->destroyIfLive(); + alloc.free_(oldTable); + } + + public: + explicit HashTable(AllocPolicy ap) + : AllocPolicy(ap) + , gen(0) + , hashShift(sHashBits) + , table(nullptr) + , entryCount(0) + , removedCount(0) + + , mutationCount(0) + , mEntered(false) + + {} + + __attribute__ ((warn_unused_result)) bool init(uint32_t length) + { + do { } while (0); + + + + + if ((__builtin_expect(!!(length > sMaxInit), 0))) { + this->reportAllocOverflow(); + return false; + } + + static_assert((sMaxInit * sAlphaDenominator) / sAlphaDenominator == sMaxInit, + "multiplication in numerator below could overflow"); + static_assert(sMaxInit * sAlphaDenominator <= (4294967295U) - sMaxAlphaNumerator, + "numerator calculation below could potentially overflow"); + + + + + uint32_t newCapacity = + (length * sAlphaDenominator + sMaxAlphaNumerator - 1) / sMaxAlphaNumerator; + if (newCapacity < sMinCapacity) + newCapacity = sMinCapacity; + + + uint32_t roundUp = sMinCapacity, roundUpLog2 = sMinCapacityLog2; + while (roundUp < newCapacity) { + roundUp <<= 1; + ++roundUpLog2; + } + + newCapacity = roundUp; + do { } while (0); + do { } while (0); + + table = createTable(*this, newCapacity); + if (!table) + return false; + + setTableSizeLog2(roundUpLog2); + memset(&stats, 0, sizeof(stats)); + return true; + } + + bool initialized() const + { + return !!table; + } + + ~HashTable() + { + if (table) + destroyTable(*this, table, capacity()); + } + + private: + HashNumber hash1(HashNumber hash0) const + { + return hash0 >> hashShift; + } + + struct DoubleHash + { + HashNumber h2; + HashNumber sizeMask; + }; + + DoubleHash hash2(HashNumber curKeyHash) const + { + unsigned sizeLog2 = sHashBits - hashShift; + DoubleHash dh = { + ((curKeyHash << sizeLog2) >> hashShift) | 1, + (HashNumber(1) << sizeLog2) - 1 + }; + return dh; + } + + static HashNumber applyDoubleHash(HashNumber h1, const DoubleHash& dh) + { + return (h1 - dh.h2) & dh.sizeMask; + } + + bool overloaded() + { + static_assert(sMaxCapacity <= (4294967295U) / sMaxAlphaNumerator, + "multiplication below could overflow"); + return entryCount + removedCount >= + capacity() * sMaxAlphaNumerator / sAlphaDenominator; + } + + + static bool wouldBeUnderloaded(uint32_t capacity, uint32_t entryCount) + { + static_assert(sMaxCapacity <= (4294967295U) / sMinAlphaNumerator, + "multiplication below could overflow"); + return capacity > sMinCapacity && + entryCount <= capacity * sMinAlphaNumerator / sAlphaDenominator; + } + + bool underloaded() + { + return wouldBeUnderloaded(capacity(), entryCount); + } + + static __attribute__((always_inline)) inline bool match(Entry& e, const Lookup& l) + { + return HashPolicy::match(HashPolicy::getKey(e.get()), l); + } + + + + + + + __attribute__((always_inline)) inline Entry& + lookup(const Lookup& l, HashNumber keyHash, unsigned collisionBit) const + { + do { } while (0); + do { } while (0); + do { } while (0); + do { } while (0); + stats.searches++; + + + HashNumber h1 = hash1(keyHash); + Entry* entry = &table[h1]; + + + if (entry->isFree()) { + stats.misses++; + return *entry; + } + + + if (entry->matchHash(keyHash) && match(*entry, l)) { + stats.hits++; + return *entry; + } + + + DoubleHash dh = hash2(keyHash); + + + Entry* firstRemoved = nullptr; + + while (true) { + if ((__builtin_expect(!!(entry->isRemoved()), 0))) { + if (!firstRemoved) + firstRemoved = entry; + } else { + if (collisionBit == sCollisionBit) + entry->setCollision(); + } + + stats.steps++; + h1 = applyDoubleHash(h1, dh); + + entry = &table[h1]; + if (entry->isFree()) { + stats.misses++; + return firstRemoved ? *firstRemoved : *entry; + } + + if (entry->matchHash(keyHash) && match(*entry, l)) { + stats.hits++; + return *entry; + } + } + } + + + + + + + + Entry& findFreeEntry(HashNumber keyHash) + { + do { } while (0); + do { } while (0); + stats.searches++; + + + + + HashNumber h1 = hash1(keyHash); + Entry* entry = &table[h1]; + + + if (!entry->isLive()) { + stats.misses++; + return *entry; + } + + + DoubleHash dh = hash2(keyHash); + + while (true) { + do { } while (0); + entry->setCollision(); + + stats.steps++; + h1 = applyDoubleHash(h1, dh); + + entry = &table[h1]; + if (!entry->isLive()) { + stats.misses++; + return *entry; + } + } + } + + enum RebuildStatus { NotOverloaded, Rehashed, RehashFailed }; + + RebuildStatus changeTableSize(int deltaLog2, FailureBehavior reportFailure = ReportFailure) + { + + Entry* oldTable = table; + uint32_t oldCap = capacity(); + uint32_t newLog2 = sHashBits - hashShift + deltaLog2; + uint32_t newCapacity = ((uint32_t)1 << (newLog2)); + if ((__builtin_expect(!!(newCapacity > sMaxCapacity), 0))) { + if (reportFailure) + this->reportAllocOverflow(); + return RehashFailed; + } + + Entry* newTable = createTable(*this, newCapacity, reportFailure); + if (!newTable) + return RehashFailed; + + + setTableSizeLog2(newLog2); + removedCount = 0; + gen++; + table = newTable; + + + Entry* end = oldTable + oldCap; + for (Entry* src = oldTable; src < end; ++src) { + if (src->isLive()) { + HashNumber hn = src->getKeyHash(); + findFreeEntry(hn).setLive( + hn, mozilla::Move(const_cast(src->get()))); + src->destroy(); + } + } + + + this->free_(oldTable); + return Rehashed; + } + + bool shouldCompressTable() + { + + return removedCount >= (capacity() >> 2); + } + + RebuildStatus checkOverloaded(FailureBehavior reportFailure = ReportFailure) + { + if (!overloaded()) + return NotOverloaded; + + int deltaLog2; + if (shouldCompressTable()) { + stats.compresses++; + deltaLog2 = 0; + } else { + stats.grows++; + deltaLog2 = 1; + } + + return changeTableSize(deltaLog2, reportFailure); + } + + + void checkOverRemoved() + { + if (overloaded()) { + if (checkOverloaded(DontReportFailure) == RehashFailed) + rehashTableInPlace(); + } + } + + void remove(Entry& e) + { + do { } while (0); + stats.removes++; + + if (e.hasCollision()) { + e.removeLive(); + removedCount++; + } else { + stats.removeFrees++; + e.clearLive(); + } + entryCount--; + + mutationCount++; + + } + + void checkUnderloaded() + { + if (underloaded()) { + stats.shrinks++; + (void) changeTableSize(-1, DontReportFailure); + } + } + + + + + void compactIfUnderloaded() + { + int32_t resizeLog2 = 0; + uint32_t newCapacity = capacity(); + while (wouldBeUnderloaded(newCapacity, entryCount)) { + newCapacity = newCapacity >> 1; + resizeLog2--; + } + + if (resizeLog2 != 0) + (void) changeTableSize(resizeLog2, DontReportFailure); + } + + + + + + + void rehashTableInPlace() + { + stats.rehashes++; + removedCount = 0; + for (size_t i = 0; i < capacity(); ++i) + table[i].unsetCollision(); + + for (size_t i = 0; i < capacity();) { + Entry* src = &table[i]; + + if (!src->isLive() || src->hasCollision()) { + ++i; + continue; + } + + HashNumber keyHash = src->getKeyHash(); + HashNumber h1 = hash1(keyHash); + DoubleHash dh = hash2(keyHash); + Entry* tgt = &table[h1]; + while (true) { + if (!tgt->hasCollision()) { + src->swap(tgt); + tgt->setCollision(); + break; + } + + h1 = applyDoubleHash(h1, dh); + tgt = &table[h1]; + } + } + + + + + + + } + + + + + + + template + void putNewInfallibleInternal(const Lookup& l, Args&&... args) + { + do { } while (0); + + HashNumber keyHash = prepareHash(l); + Entry* entry = &findFreeEntry(keyHash); + do { } while (0); + + if (entry->isRemoved()) { + stats.addOverRemoved++; + removedCount--; + keyHash |= sCollisionBit; + } + + entry->setLive(keyHash, mozilla::Forward(args)...); + entryCount++; + + mutationCount++; + + } + + public: + void clear() + { + if (mozilla::IsPod::value) { + memset(table, 0, sizeof(*table) * capacity()); + } else { + uint32_t tableCapacity = capacity(); + Entry* end = table + tableCapacity; + for (Entry* e = table; e < end; ++e) + e->clear(); + } + removedCount = 0; + entryCount = 0; + + mutationCount++; + + } + + void clearAndShrink() + { + clear(); + compactIfUnderloaded(); + } + + void finish() + { + + do { } while (0); + + if (!table) + return; + + destroyTable(*this, table, capacity()); + table = nullptr; + gen++; + entryCount = 0; + removedCount = 0; + + mutationCount++; + + } + + Range all() const + { + do { } while (0); + return Range(*this, table, table + capacity()); + } + + bool empty() const + { + do { } while (0); + return !entryCount; + } + + uint32_t count() const + { + do { } while (0); + return entryCount; + } + + uint32_t capacity() const + { + do { } while (0); + return ((uint32_t)1 << (sHashBits - hashShift)); + } + + Generation generation() const + { + do { } while (0); + return Generation(gen); + } + + size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const + { + return mallocSizeOf(table); + } + + size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const + { + return mallocSizeOf(this) + sizeOfExcludingThis(mallocSizeOf); + } + + __attribute__((always_inline)) inline Ptr lookup(const Lookup& l) const + { + mozilla::ReentrancyGuard g(*this); + if (!HasHash(l)) + return Ptr(); + HashNumber keyHash = prepareHash(l); + return Ptr(lookup(l, keyHash, 0), *this); + } + + __attribute__((always_inline)) inline Ptr readonlyThreadsafeLookup(const Lookup& l) const + { + if (!HasHash(l)) + return Ptr(); + HashNumber keyHash = prepareHash(l); + return Ptr(lookup(l, keyHash, 0), *this); + } + + __attribute__((always_inline)) inline AddPtr lookupForAdd(const Lookup& l) const + { + mozilla::ReentrancyGuard g(*this); + if (!EnsureHash(l)) + return AddPtr(); + HashNumber keyHash = prepareHash(l); + Entry& entry = lookup(l, keyHash, sCollisionBit); + AddPtr p(entry, *this, keyHash); + return p; + } + + template + __attribute__ ((warn_unused_result)) bool add(AddPtr& p, Args&&... args) + { + mozilla::ReentrancyGuard g(*this); + do { } while (0); + do { } while (0); + do { } while (0); + + + if (p.isValid()) + return false; + + + + if (p.entry_->isRemoved()) { + if (!this->checkSimulatedOOM()) + return false; + stats.addOverRemoved++; + removedCount--; + p.keyHash |= sCollisionBit; + } else { + + RebuildStatus status = checkOverloaded(); + if (status == RehashFailed) + return false; + if (status == NotOverloaded && !this->checkSimulatedOOM()) + return false; + if (status == Rehashed) + p.entry_ = &findFreeEntry(p.keyHash); + } + + p.entry_->setLive(p.keyHash, mozilla::Forward(args)...); + entryCount++; + + mutationCount++; + p.generation = generation(); + p.mutationCount = mutationCount; + + return true; + } + + + + template + void putNewInfallible(const Lookup& l, Args&&... args) + { + do { } while (0); + mozilla::ReentrancyGuard g(*this); + putNewInfallibleInternal(l, mozilla::Forward(args)...); + } + + + + template + __attribute__ ((warn_unused_result)) bool putNew(const Lookup& l, Args&&... args) + { + if (!this->checkSimulatedOOM()) + return false; + + if (!EnsureHash(l)) + return false; + + if (checkOverloaded() == RehashFailed) + return false; + + putNewInfallible(l, mozilla::Forward(args)...); + return true; + } + + + + template + __attribute__ ((warn_unused_result)) bool relookupOrAdd(AddPtr& p, const Lookup& l, Args&&... args) + { + + if (p.isValid()) + return false; + + + p.generation = generation(); + p.mutationCount = mutationCount; + + { + mozilla::ReentrancyGuard g(*this); + do { } while (0); + p.entry_ = &lookup(l, p.keyHash, sCollisionBit); + } + return p.found() || add(p, mozilla::Forward(args)...); + } + + void remove(Ptr p) + { + do { } while (0); + mozilla::ReentrancyGuard g(*this); + do { } while (0); + remove(*p.entry_); + checkUnderloaded(); + } + + void rekeyWithoutRehash(Ptr p, const Lookup& l, const Key& k) + { + do { } while (0); + mozilla::ReentrancyGuard g(*this); + do { } while (0); + typename HashTableEntry::NonConstT t(mozilla::Move(*p)); + HashPolicy::setKey(t, const_cast(k)); + remove(*p.entry_); + putNewInfallibleInternal(l, mozilla::Move(t)); + } + + void rekeyAndMaybeRehash(Ptr p, const Lookup& l, const Key& k) + { + rekeyWithoutRehash(p, l, k); + checkOverRemoved(); + } + + +}; + +} +} +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h" 2 + + + +class JSTracer; + +namespace JS { +class CallbackTracer; +template class Heap; +template class TenuredHeap; + + +const char* +GCTraceKindToAscii(JS::TraceKind kind); + +} + +enum WeakMapTraceKind { + + + + + DoNotTraceWeakMaps, + + + + + + ExpandWeakMaps, + + + + + + TraceWeakMapValues, + + + + + + TraceWeakMapKeysValues +}; + +class JSTracer +{ + public: + + JSRuntime* runtime() const { return runtime_; } + + + WeakMapTraceKind weakMapAction() const { return weakMapAction_; } + + enum class TracerKindTag { + + + + Marking, + + + + + + WeakMarking, + + + + Tenuring, + + + + Callback + }; + bool isMarkingTracer() const { return tag_ == TracerKindTag::Marking || tag_ == TracerKindTag::WeakMarking; } + bool isWeakMarkingTracer() const { return tag_ == TracerKindTag::WeakMarking; } + bool isTenuringTracer() const { return tag_ == TracerKindTag::Tenuring; } + bool isCallbackTracer() const { return tag_ == TracerKindTag::Callback; } + inline JS::CallbackTracer* asCallbackTracer(); + bool traceWeakEdges() const { return traceWeakEdges_; } + + + + + protected: + JSTracer(JSRuntime* rt, TracerKindTag tag, + WeakMapTraceKind weakTraceKind = TraceWeakMapValues) + : runtime_(rt) + , weakMapAction_(weakTraceKind) + + + + , tag_(tag) + , traceWeakEdges_(true) + {} +# 113 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h" + private: + JSRuntime* runtime_; + WeakMapTraceKind weakMapAction_; + + + + + protected: + TracerKindTag tag_; + bool traceWeakEdges_; +}; + +namespace JS { + +class AutoTracingName; +class AutoTracingIndex; +class AutoTracingCallback; + +class CallbackTracer : public JSTracer +{ + public: + CallbackTracer(JSRuntime* rt, WeakMapTraceKind weakTraceKind = TraceWeakMapValues) + : JSTracer(rt, JSTracer::TracerKindTag::Callback, weakTraceKind), + contextName_(nullptr), contextIndex_(InvalidIndex), contextFunctor_(nullptr) + {} + CallbackTracer(JSContext* cx, WeakMapTraceKind weakTraceKind = TraceWeakMapValues); + + + + + + + virtual void onObjectEdge(JSObject** objp) { onChild(JS::GCCellPtr(*objp)); } + virtual void onStringEdge(JSString** strp) { onChild(JS::GCCellPtr(*strp)); } + virtual void onSymbolEdge(JS::Symbol** symp) { onChild(JS::GCCellPtr(*symp)); } + virtual void onScriptEdge(JSScript** scriptp) { onChild(JS::GCCellPtr(*scriptp)); } + virtual void onShapeEdge(js::Shape** shapep) { + onChild(JS::GCCellPtr(*shapep, JS::TraceKind::Shape)); + } + virtual void onObjectGroupEdge(js::ObjectGroup** groupp) { + onChild(JS::GCCellPtr(*groupp, JS::TraceKind::ObjectGroup)); + } + virtual void onBaseShapeEdge(js::BaseShape** basep) { + onChild(JS::GCCellPtr(*basep, JS::TraceKind::BaseShape)); + } + virtual void onJitCodeEdge(js::jit::JitCode** codep) { + onChild(JS::GCCellPtr(*codep, JS::TraceKind::JitCode)); + } + virtual void onLazyScriptEdge(js::LazyScript** lazyp) { + onChild(JS::GCCellPtr(*lazyp, JS::TraceKind::LazyScript)); + } + virtual void onScopeEdge(js::Scope** scopep) { + onChild(JS::GCCellPtr(*scopep, JS::TraceKind::Scope)); + } + virtual void onRegExpSharedEdge(js::RegExpShared** sharedp) { + onChild(JS::GCCellPtr(*sharedp, JS::TraceKind::RegExpShared)); + } + + + + virtual void onChild(const JS::GCCellPtr& thing) = 0; +# 195 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h" + const char* contextName() const { do { } while (0); return contextName_; } + + + + + const static size_t InvalidIndex = size_t(-1); + size_t contextIndex() const { return contextIndex_; } + + + + + + + void getTracingEdgeName(char* buffer, size_t bufferSize); + + + + + + + class ContextFunctor { + public: + virtual void operator()(CallbackTracer* trc, char* buf, size_t bufsize) = 0; + }; +# 230 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h" + void dispatchToOnEdge(JSObject** objp) { onObjectEdge(objp); } + void dispatchToOnEdge(JSString** strp) { onStringEdge(strp); } + void dispatchToOnEdge(JS::Symbol** symp) { onSymbolEdge(symp); } + void dispatchToOnEdge(JSScript** scriptp) { onScriptEdge(scriptp); } + void dispatchToOnEdge(js::Shape** shapep) { onShapeEdge(shapep); } + void dispatchToOnEdge(js::ObjectGroup** groupp) { onObjectGroupEdge(groupp); } + void dispatchToOnEdge(js::BaseShape** basep) { onBaseShapeEdge(basep); } + void dispatchToOnEdge(js::jit::JitCode** codep) { onJitCodeEdge(codep); } + void dispatchToOnEdge(js::LazyScript** lazyp) { onLazyScriptEdge(lazyp); } + void dispatchToOnEdge(js::Scope** scopep) { onScopeEdge(scopep); } + void dispatchToOnEdge(js::RegExpShared** sharedp) { onRegExpSharedEdge(sharedp); } + + protected: + void setTraceWeakEdges(bool value) { + traceWeakEdges_ = value; + } + + private: + friend class AutoTracingName; + const char* contextName_; + + friend class AutoTracingIndex; + size_t contextIndex_; + + friend class AutoTracingDetails; + ContextFunctor* contextFunctor_; +}; + + +class AutoTracingName +{ + CallbackTracer* trc_; + const char* prior_; + + public: + AutoTracingName(CallbackTracer* trc, const char* name) : trc_(trc), prior_(trc->contextName_) { + do { } while (0); + trc->contextName_ = name; + } + ~AutoTracingName() { + do { } while (0); + trc_->contextName_ = prior_; + } +}; + + +class AutoTracingIndex +{ + CallbackTracer* trc_; + + public: + explicit AutoTracingIndex(JSTracer* trc, size_t initial = 0) : trc_(nullptr) { + if (trc->isCallbackTracer()) { + trc_ = trc->asCallbackTracer(); + do { } while (0); + trc_->contextIndex_ = initial; + } + } + ~AutoTracingIndex() { + if (trc_) { + do { } while (0); + trc_->contextIndex_ = CallbackTracer::InvalidIndex; + } + } + + void operator++() { + if (trc_) { + do { } while (0); + ++trc_->contextIndex_; + } + } +}; + + + +class AutoTracingDetails +{ + CallbackTracer* trc_; + + public: + AutoTracingDetails(JSTracer* trc, CallbackTracer::ContextFunctor& func) : trc_(nullptr) { + if (trc->isCallbackTracer()) { + trc_ = trc->asCallbackTracer(); + do { } while (0); + trc_->contextFunctor_ = &func; + } + } + ~AutoTracingDetails() { + if (trc_) { + do { } while (0); + trc_->contextFunctor_ = nullptr; + } + } +}; + +} + +JS::CallbackTracer* +JSTracer::asCallbackTracer() +{ + do { } while (0); + return static_cast(this); +} + +namespace JS { +# 350 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h" +template +extern void +TraceEdge(JSTracer* trc, JS::Heap* edgep, const char* name); + +extern void +TraceEdge(JSTracer* trc, JS::TenuredHeap* edgep, const char* name); + + + + + + + +template +extern void +UnsafeTraceRoot(JSTracer* trc, T* edgep, const char* name); + +extern void +TraceChildren(JSTracer* trc, GCCellPtr thing); + +using ZoneSet = js::HashSet, js::SystemAllocPolicy>; +using CompartmentSet = js::HashSet, + js::SystemAllocPolicy>; + + + + + + +extern void +TraceIncomingCCWs(JSTracer* trc, const JS::CompartmentSet& compartments); + +} + +extern void +JS_GetTraceThingInfo(char* buf, size_t bufsize, JSTracer* trc, + void* thing, JS::TraceKind kind, bool includeDetails); + +namespace js { + + + + + + +template +extern void +UnsafeTraceManuallyBarrieredEdge(JSTracer* trc, T* edgep, const char* name); + +namespace gc { + + +template +extern bool +EdgeNeedsSweep(JS::Heap* edgep); + + + +template +bool +IsAboutToBeFinalizedUnbarriered(T* thingp); + +} +} +# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCPolicyAPI.h" 2 +# 65 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCPolicyAPI.h" +class JSAtom; +class JSFunction; +class JSObject; +class JSScript; +class JSString; +namespace JS { +class Symbol; +} + +namespace JS { + + + +template +struct StructGCPolicy +{ + static T initial() { + return T(); + } + + static void trace(JSTracer* trc, T* tp, const char* name) { + tp->trace(trc); + } + + static void sweep(T* tp) { + return tp->sweep(); + } + + static bool needsSweep(T* tp) { + return tp->needsSweep(); + } +}; + + + + + +template struct GCPolicy : public StructGCPolicy {}; + + +template +struct IgnoreGCPolicy { + static T initial() { return T(); } + static void trace(JSTracer* trc, T* t, const char* name) {} + static bool needsSweep(T* v) { return false; } +}; +template <> struct GCPolicy : public IgnoreGCPolicy {}; +template <> struct GCPolicy : public IgnoreGCPolicy {}; + +template +struct GCPointerPolicy +{ + static T initial() { return nullptr; } + static void trace(JSTracer* trc, T* vp, const char* name) { + if (*vp) + js::UnsafeTraceManuallyBarrieredEdge(trc, vp, name); + } + static bool needsSweep(T* vp) { + if (*vp) + return js::gc::IsAboutToBeFinalizedUnbarriered(vp); + return false; + } +}; +template <> struct GCPolicy : public GCPointerPolicy {}; +template <> struct GCPolicy : public GCPointerPolicy {}; +template <> struct GCPolicy : public GCPointerPolicy {}; +template <> struct GCPolicy : public GCPointerPolicy {}; +template <> struct GCPolicy : public GCPointerPolicy {}; +template <> struct GCPolicy : public GCPointerPolicy {}; + +template +struct GCPolicy> +{ + static void trace(JSTracer* trc, JS::Heap* thingp, const char* name) { + TraceEdge(trc, thingp, name); + } + static bool needsSweep(JS::Heap* thingp) { + return js::gc::EdgeNeedsSweep(thingp); + } +}; + + +template +struct GCPolicy> +{ + static mozilla::UniquePtr initial() { return mozilla::UniquePtr(); } + static void trace(JSTracer* trc, mozilla::UniquePtr* tp, const char* name) { + if (tp->get()) + GCPolicy::trace(trc, tp->get(), name); + } + static bool needsSweep(mozilla::UniquePtr* tp) { + if (tp->get()) + return GCPolicy::needsSweep(tp->get()); + return false; + } +}; + +} +# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" 2 +# 110 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" +namespace js { + +template +struct BarrierMethods { +}; + +template +class WrappedPtrOperations {}; + +template +class MutableWrappedPtrOperations : public WrappedPtrOperations {}; + +template +class RootedBase : public MutableWrappedPtrOperations {}; + +template +class HandleBase : public WrappedPtrOperations {}; + +template +class MutableHandleBase : public MutableWrappedPtrOperations {}; + +template +class HeapBase : public MutableWrappedPtrOperations {}; + + +template struct IsHeapConstructibleType { static constexpr bool value = false; }; + + +template <> struct IsHeapConstructibleType { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType { static constexpr bool value = true; }; +template <> struct IsHeapConstructibleType { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType { static constexpr bool value = true; }; + + +template +class PersistentRootedBase : public MutableWrappedPtrOperations {}; + +namespace gc { +struct Cell; +template +struct PersistentRootedMarker; +} +# 182 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" +} + +namespace JS { + +template class Rooted; +template class PersistentRooted; + + +bool isGCEnabled(); + +void HeapObjectPostBarrier(JSObject** objp, JSObject* prev, JSObject* next); + + + + + + +extern void +AssertGCThingMustBeTenured(JSObject* obj); +extern void +AssertGCThingIsNotAnObjectSubclass(js::gc::Cell* cell); +# 229 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" +template +class Heap : public js::HeapBase> +{ + + static_assert(js::IsHeapConstructibleType::value, + "Type T must be a public GC pointer type"); + public: + using ElementType = T; + + Heap() { + static_assert(sizeof(T) == sizeof(Heap), + "Heap must be binary compatible with T."); + init(GCPolicy::initial()); + } + explicit Heap(const T& p) { init(p); } + + + + + + + + explicit Heap(const Heap& p) { init(p.ptr); } + + ~Heap() { + post(ptr, GCPolicy::initial()); + } + + operator const T&() const { return get(); } const T& operator->() const { return get(); }; + Heap& operator=(const T& p) { set(p); return *this; } Heap& operator=(const Heap& other) { set(other.get()); return *this; }; + + const T* address() const { return &ptr; } + + void exposeToActiveJS() const { + js::BarrierMethods::exposeToJS(ptr); + } + const T& get() const { + exposeToActiveJS(); + return ptr; + } + const T& unbarrieredGet() const { + return ptr; + } + + T* unsafeGet() { return &ptr; } + + explicit operator bool() const { + return bool(js::BarrierMethods::asGCThingOrNull(ptr)); + } + explicit operator bool() { + return bool(js::BarrierMethods::asGCThingOrNull(ptr)); + } + + private: + void init(const T& newPtr) { + ptr = newPtr; + post(GCPolicy::initial(), ptr); + } + + void set(const T& newPtr) { + T tmp = ptr; + ptr = newPtr; + post(tmp, ptr); + } + + void post(const T& prev, const T& next) { + js::BarrierMethods::postBarrier(&ptr, prev, next); + } + + T ptr; +}; + +static __attribute__((always_inline)) inline bool +ObjectIsTenured(JSObject* obj) +{ + return !js::gc::IsInsideNursery(reinterpret_cast(obj)); +} + +static __attribute__((always_inline)) inline bool +ObjectIsTenured(const Heap& obj) +{ + return ObjectIsTenured(obj.unbarrieredGet()); +} + +static __attribute__((always_inline)) inline bool +ObjectIsMarkedGray(JSObject* obj) +{ + auto cell = reinterpret_cast(obj); + return js::gc::detail::CellIsMarkedGrayIfKnown(cell); +} + +static __attribute__((always_inline)) inline bool +ObjectIsMarkedGray(const JS::Heap& obj) +{ + return ObjectIsMarkedGray(obj.unbarrieredGet()); +} +# 380 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" +template +class TenuredHeap : public js::HeapBase> +{ + public: + using ElementType = T; + + TenuredHeap() : bits(0) { + static_assert(sizeof(T) == sizeof(TenuredHeap), + "TenuredHeap must be binary compatible with T."); + } + explicit TenuredHeap(T p) : bits(0) { setPtr(p); } + explicit TenuredHeap(const TenuredHeap& p) : bits(0) { setPtr(p.getPtr()); } + + void setPtr(T newPtr) { + do { } while (0); + if (newPtr) + AssertGCThingMustBeTenured(newPtr); + bits = (bits & flagsMask) | reinterpret_cast(newPtr); + } + + void setFlags(uintptr_t flagsToSet) { + do { } while (0); + bits |= flagsToSet; + } + + void unsetFlags(uintptr_t flagsToUnset) { + do { } while (0); + bits &= ~flagsToUnset; + } + + bool hasFlag(uintptr_t flag) const { + do { } while (0); + return (bits & flag) != 0; + } + + T unbarrieredGetPtr() const { return reinterpret_cast(bits & ~flagsMask); } + uintptr_t getFlags() const { return bits & flagsMask; } + + void exposeToActiveJS() const { + js::BarrierMethods::exposeToJS(unbarrieredGetPtr()); + } + T getPtr() const { + exposeToActiveJS(); + return unbarrieredGetPtr(); + } + + operator T() const { return getPtr(); } + T operator->() const { return getPtr(); } + + explicit operator bool() const { + return bool(js::BarrierMethods::asGCThingOrNull(unbarrieredGetPtr())); + } + explicit operator bool() { + return bool(js::BarrierMethods::asGCThingOrNull(unbarrieredGetPtr())); + } + + TenuredHeap& operator=(T p) { + setPtr(p); + return *this; + } + + TenuredHeap& operator=(const TenuredHeap& other) { + bits = other.bits; + return *this; + } + + private: + enum { + maskBits = 3, + flagsMask = (1 << maskBits) - 1, + }; + + uintptr_t bits; +}; +# 463 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" +template +class Handle : public js::HandleBase> +{ + friend class JS::MutableHandle; + + public: + using ElementType = T; + + + template + Handle(Handle handle, + typename mozilla::EnableIf::value, int>::Type dummy = 0) + { + static_assert(sizeof(Handle) == sizeof(T*), + "Handle must be binary compatible with T*."); + ptr = reinterpret_cast(handle.address()); + } + + Handle(decltype(nullptr)) { + static_assert(mozilla::IsPointer::value, + "nullptr_t overload not valid for non-pointer types"); + static void* const ConstNullValue = nullptr; + ptr = reinterpret_cast(&ConstNullValue); + } + + Handle(MutableHandle handle) { + ptr = handle.address(); + } +# 507 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" + static constexpr Handle fromMarkedLocation(const T* p) { + return Handle(p, DeliberatelyChoosingThisOverload, + ImUsingThisOnlyInFromFromMarkedLocation); + } + + + + + + template + inline + Handle(const Rooted& root, + typename mozilla::EnableIf::value, int>::Type dummy = 0); + + template + inline + Handle(const PersistentRooted& root, + typename mozilla::EnableIf::value, int>::Type dummy = 0); + + + template + inline + Handle(MutableHandle& root, + typename mozilla::EnableIf::value, int>::Type dummy = 0); + + operator const T&() const { return get(); } const T& operator->() const { return get(); }; + const T* address() const { return &(*ptr); } const T& get() const { return (*ptr); }; + + private: + Handle() {} + template Handle& operator=(S) = delete; Handle& operator=(const Handle&) = delete;; + + enum Disambiguator { DeliberatelyChoosingThisOverload = 42 }; + enum CallerIdentity { ImUsingThisOnlyInFromFromMarkedLocation = 17 }; + constexpr Handle(const T* p, Disambiguator, CallerIdentity) : ptr(p) {} + + const T* ptr; +}; +# 554 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" +template +class MutableHandle : public js::MutableHandleBase> +{ + public: + using ElementType = T; + + inline MutableHandle(Rooted* root); + inline MutableHandle(PersistentRooted* root); + + private: + + MutableHandle(decltype(nullptr)) = delete; + + public: + void set(const T& v) { + *ptr = v; + } +# 579 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" + static MutableHandle fromMarkedLocation(T* p) { + MutableHandle h; + h.ptr = p; + return h; + } + + operator const T&() const { return get(); } const T& operator->() const { return get(); }; + const T* address() const { return &(*ptr); } const T& get() const { return (*ptr); }; + T* address() { return &(*ptr); } T& get() { return (*ptr); }; + + private: + MutableHandle() {} + template MutableHandle& operator=(S) = delete; MutableHandle& operator=(const MutableHandle&) = delete;; + + T* ptr; +}; + +} + +namespace js { + +template +struct BarrierMethods +{ + static T* initial() { return nullptr; } + static gc::Cell* asGCThingOrNull(T* v) { + if (!v) + return nullptr; + do { } while (0); + return reinterpret_cast(v); + } + static void postBarrier(T** vp, T* prev, T* next) { + if (next) + JS::AssertGCThingIsNotAnObjectSubclass(reinterpret_cast(next)); + } + static void exposeToJS(T* t) { + if (t) + js::gc::ExposeGCThingToActiveJS(JS::GCCellPtr(t)); + } +}; + +template <> +struct BarrierMethods +{ + static JSObject* initial() { return nullptr; } + static gc::Cell* asGCThingOrNull(JSObject* v) { + if (!v) + return nullptr; + do { } while (0); + return reinterpret_cast(v); + } + static void postBarrier(JSObject** vp, JSObject* prev, JSObject* next) { + JS::HeapObjectPostBarrier(vp, prev, next); + } + static void exposeToJS(JSObject* obj) { + if (obj) + JS::ExposeObjectToActiveJS(obj); + } +}; + +template <> +struct BarrierMethods +{ + static JSFunction* initial() { return nullptr; } + static gc::Cell* asGCThingOrNull(JSFunction* v) { + if (!v) + return nullptr; + do { } while (0); + return reinterpret_cast(v); + } + static void postBarrier(JSFunction** vp, JSFunction* prev, JSFunction* next) { + JS::HeapObjectPostBarrier(reinterpret_cast(vp), + reinterpret_cast(prev), + reinterpret_cast(next)); + } + static void exposeToJS(JSFunction* fun) { + if (fun) + JS::ExposeObjectToActiveJS(reinterpret_cast(fun)); + } +}; +# 671 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" +template +struct MovableCellHasher +{ + using Key = T; + using Lookup = T; + + static bool hasHash(const Lookup& l); + static bool ensureHash(const Lookup& l); + static HashNumber hash(const Lookup& l); + static bool match(const Key& k, const Lookup& l); + static void rekey(Key& k, const Key& newKey) { k = newKey; } +}; + +template +struct MovableCellHasher> +{ + using Key = JS::Heap; + using Lookup = T; + + static bool hasHash(const Lookup& l) { return MovableCellHasher::hasHash(l); } + static bool ensureHash(const Lookup& l) { return MovableCellHasher::ensureHash(l); } + static HashNumber hash(const Lookup& l) { return MovableCellHasher::hash(l); } + static bool match(const Key& k, const Lookup& l) { + return MovableCellHasher::match(k.unbarrieredGet(), l); + } + static void rekey(Key& k, const Key& newKey) { k.unsafeSet(newKey); } +}; + +template +struct FallibleHashMethods> +{ + template static bool hasHash(Lookup&& l) { + return MovableCellHasher::hasHash(mozilla::Forward(l)); + } + template static bool ensureHash(Lookup&& l) { + return MovableCellHasher::ensureHash(mozilla::Forward(l)); + } +}; + +} + +namespace js { +# 722 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" +template +class alignas(8) DispatchWrapper +{ + static_assert(JS::MapTypeToRootKind::kind == JS::RootKind::Traceable, + "DispatchWrapper is intended only for usage with a Traceable"); + + using TraceFn = void (*)(JSTracer*, T*, const char*); + TraceFn tracer; + alignas(gc::CellSize) T storage; + + public: + template + DispatchWrapper(U&& initial) + : tracer(&JS::GCPolicy::trace), + storage(mozilla::Forward(initial)) + { } + + + T* operator &() { return &storage; } + const T* operator &() const { return &storage; } + operator T&() { return storage; } + operator const T&() const { return storage; } + + + + static void TraceWrapped(JSTracer* trc, T* thingp, const char* name) { + auto wrapper = reinterpret_cast( + uintptr_t(thingp) - __builtin_offsetof(DispatchWrapper, storage)); + wrapper->tracer(trc, &wrapper->storage, name); + } +}; + +} + +namespace JS { +# 766 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" +template +class Rooted : public js::RootedBase> +{ + inline void registerWithRootLists(RootedListHeads& roots) { + this->stack = &roots[JS::MapTypeToRootKind::kind]; + this->prev = *stack; + *stack = reinterpret_cast*>(this); + } + + inline RootedListHeads& rootLists(RootingContext* cx) { + return cx->stackRoots_; + } + inline RootedListHeads& rootLists(JSContext* cx) { + return rootLists(RootingContext::get(cx)); + } + + public: + using ElementType = T; + + template + explicit Rooted(const RootingContext& cx) + : ptr(GCPolicy::initial()) + { + registerWithRootLists(rootLists(cx)); + } + + template + Rooted(const RootingContext& cx, S&& initial) + : ptr(mozilla::Forward(initial)) + { + registerWithRootLists(rootLists(cx)); + } + + ~Rooted() { + do { } while (0); + *stack = prev; + } + + Rooted* previous() { return reinterpret_cast*>(prev); } + + + + + + void set(const T& value) { + ptr = value; + } + + operator const T&() const { return get(); } const T& operator->() const { return get(); }; + Rooted& operator=(const T& p) { set(p); return *this; } Rooted& operator=(const Rooted& other) { set(other.get()); return *this; }; + const T* address() const { return &(ptr); } const T& get() const { return (ptr); }; + T* address() { return &(ptr); } T& get() { return (ptr); }; + + private: + + + + + + Rooted** stack; + Rooted* prev; +# 836 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" + using MaybeWrapped = typename mozilla::Conditional< + MapTypeToRootKind::kind == JS::RootKind::Traceable, + js::DispatchWrapper, + T>::Type; + MaybeWrapped ptr; + + Rooted(const Rooted&) = delete; +} ; + +} + +namespace js { +# 859 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" +template +class RootedBase : public MutableWrappedPtrOperations +{ + public: + template + JS::Handle as() const; +}; +# 877 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" +template +class HandleBase : public WrappedPtrOperations +{ + public: + template + JS::Handle as() const; +}; + + +template +class FakeRooted : public RootedBase> +{ + public: + using ElementType = T; + + template + explicit FakeRooted(CX* cx) : ptr(JS::GCPolicy::initial()) {} + + template + FakeRooted(CX* cx, T initial) : ptr(initial) {} + + operator const T&() const { return get(); } const T& operator->() const { return get(); }; + FakeRooted& operator=(const T& p) { set(p); return *this; } FakeRooted& operator=(const FakeRooted& other) { set(other.get()); return *this; }; + const T* address() const { return &(ptr); } const T& get() const { return (ptr); }; + T* address() { return &(ptr); } T& get() { return (ptr); }; + + private: + T ptr; + + void set(const T& value) { + ptr = value; + } + + FakeRooted(const FakeRooted&) = delete; +}; + + +template +class FakeMutableHandle : public js::MutableHandleBase> +{ + public: + using ElementType = T; + + FakeMutableHandle(T* t) { + ptr = t; + } + + FakeMutableHandle(FakeRooted* root) { + ptr = root->address(); + } + + void set(const T& v) { + *ptr = v; + } + + operator const T&() const { return get(); } const T& operator->() const { return get(); }; + const T* address() const { return &(*ptr); } const T& get() const { return (*ptr); }; + T* address() { return &(*ptr); } T& get() { return (*ptr); }; + + private: + FakeMutableHandle() {} + template FakeMutableHandle& operator=(S) = delete; FakeMutableHandle& operator=(const FakeMutableHandle&) = delete;; + + T* ptr; +}; +# 952 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" +enum AllowGC { + NoGC = 0, + CanGC = 1 +}; +template +class MaybeRooted +{ +}; + +template class MaybeRooted +{ + public: + typedef JS::Handle HandleType; + typedef JS::Rooted RootType; + typedef JS::MutableHandle MutableHandleType; + + static inline JS::Handle toHandle(HandleType v) { + return v; + } + + static inline JS::MutableHandle toMutableHandle(MutableHandleType v) { + return v; + } + + template + static inline JS::Handle downcastHandle(HandleType v) { + return v.template as(); + } +}; + +template class MaybeRooted +{ + public: + typedef const T& HandleType; + typedef FakeRooted RootType; + typedef FakeMutableHandle MutableHandleType; + + static JS::Handle toHandle(HandleType v) { + do { AnnotateMozCrashReason("MOZ_CRASH(" "Bad conversion" ")"); do { *((volatile int*) __null) = 990; ::abort(); } while (0); } while (0); + } + + static JS::MutableHandle toMutableHandle(MutableHandleType v) { + do { AnnotateMozCrashReason("MOZ_CRASH(" "Bad conversion" ")"); do { *((volatile int*) __null) = 994; ::abort(); } while (0); } while (0); + } + + template + static inline T2* downcastHandle(HandleType v) { + return &v->template as(); + } +}; + +} + +namespace JS { + +template template +inline +Handle::Handle(const Rooted& root, + typename mozilla::EnableIf::value, int>::Type dummy) +{ + ptr = reinterpret_cast(root.address()); +} + +template template +inline +Handle::Handle(const PersistentRooted& root, + typename mozilla::EnableIf::value, int>::Type dummy) +{ + ptr = reinterpret_cast(root.address()); +} + +template template +inline +Handle::Handle(MutableHandle& root, + typename mozilla::EnableIf::value, int>::Type dummy) +{ + ptr = reinterpret_cast(root.address()); +} + +template +inline +MutableHandle::MutableHandle(Rooted* root) +{ + static_assert(sizeof(MutableHandle) == sizeof(T*), + "MutableHandle must be binary compatible with T*."); + ptr = root->address(); +} + +template +inline +MutableHandle::MutableHandle(PersistentRooted* root) +{ + static_assert(sizeof(MutableHandle) == sizeof(T*), + "MutableHandle must be binary compatible with T*."); + ptr = root->address(); +} + +void +AddPersistentRoot(RootingContext* cx, RootKind kind, PersistentRooted* root); +# 1086 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" +template +class PersistentRooted : public js::RootedBase>, + private mozilla::LinkedListElement> +{ + using ListBase = mozilla::LinkedListElement>; + + friend class mozilla::LinkedList; + friend class mozilla::LinkedListElement; + + void registerWithRootLists(RootingContext* cx) { + do { } while (0); + JS::RootKind kind = JS::MapTypeToRootKind::kind; + AddPersistentRoot(cx, kind, reinterpret_cast*>(this)); + } + + public: + using ElementType = T; + + PersistentRooted() : ptr(GCPolicy::initial()) {} + + explicit PersistentRooted(RootingContext* cx) + : ptr(GCPolicy::initial()) + { + registerWithRootLists(cx); + } + + explicit PersistentRooted(JSContext* cx) + : ptr(GCPolicy::initial()) + { + registerWithRootLists(RootingContext::get(cx)); + } + + template + PersistentRooted(RootingContext* cx, U&& initial) + : ptr(mozilla::Forward(initial)) + { + registerWithRootLists(cx); + } + + template + PersistentRooted(JSContext* cx, U&& initial) + : ptr(mozilla::Forward(initial)) + { + registerWithRootLists(RootingContext::get(cx)); + } + + PersistentRooted(const PersistentRooted& rhs) + : mozilla::LinkedListElement>(), + ptr(rhs.ptr) + { +# 1144 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" + const_cast(rhs).setNext(this); + } + + bool initialized() { + return ListBase::isInList(); + } + + void init(JSContext* cx) { + init(cx, GCPolicy::initial()); + } + + template + void init(JSContext* cx, U&& initial) { + ptr = mozilla::Forward(initial); + registerWithRootLists(RootingContext::get(cx)); + } + + void reset() { + if (initialized()) { + set(GCPolicy::initial()); + ListBase::remove(); + } + } + + operator const T&() const { return get(); } const T& operator->() const { return get(); }; + PersistentRooted& operator=(const T& p) { set(p); return *this; } PersistentRooted& operator=(const PersistentRooted& other) { set(other.get()); return *this; }; + const T* address() const { return &(ptr); } const T& get() const { return (ptr); }; + + + + + T* address() { + do { } while (0); + return &ptr; + } + T& get() { + do { } while (0); + return ptr; + } + + private: + template + void set(U&& value) { + do { } while (0); + ptr = mozilla::Forward(value); + } + + + using MaybeWrapped = typename mozilla::Conditional< + MapTypeToRootKind::kind == JS::RootKind::Traceable, + js::DispatchWrapper, + T>::Type; + MaybeWrapped ptr; +} ; + +class ObjectPtr +{ + Heap value; + + public: + using ElementType = JSObject*; + + ObjectPtr() : value(nullptr) {} + + explicit ObjectPtr(JSObject* obj) : value(obj) {} + + + ~ObjectPtr() { do { } while (0); } + + void finalize(JSRuntime* rt); + void finalize(JSContext* cx); + + void init(JSObject* obj) { value = obj; } + + JSObject* get() const { return value; } + JSObject* unbarrieredGet() const { return value.unbarrieredGet(); } + + void writeBarrierPre(JSContext* cx) { + IncrementalPreWriteBarrier(value); + } + + void updateWeakPointerAfterGC(); + + ObjectPtr& operator=(JSObject* obj) { + IncrementalPreWriteBarrier(value); + value = obj; + return *this; + } + + void trace(JSTracer* trc, const char* name); + + JSObject& operator*() const { return *value; } + JSObject* operator->() const { return value; } + operator JSObject*() const { return value; } + + explicit operator bool() const { return value.unbarrieredGet(); } + explicit operator bool() { return value.unbarrieredGet(); } +}; + +} + +namespace js { + +template +class WrappedPtrOperations, Container> +{ + const UniquePtr& uniquePtr() const { return static_cast(this)->get(); } + + public: + explicit operator bool() const { return !!uniquePtr(); } +}; + +template +class MutableWrappedPtrOperations, Container> + : public WrappedPtrOperations, Container> +{ + UniquePtr& uniquePtr() { return static_cast(this)->get(); } + + public: + __attribute__ ((warn_unused_result)) typename UniquePtr::Pointer release() { return uniquePtr().release(); } +}; + +namespace gc { + +template +void +CallTraceCallbackOnNonHeap(T* v, const TraceCallbacks& aCallbacks, const char* aName, void* aClosure) +{ + static_assert(sizeof(T) == sizeof(JS::Heap), "T and Heap must be compatible."); + do { } while (0); + mozilla::DebugOnly cell = BarrierMethods::asGCThingOrNull(*v); + do { } while (0); + do { } while (0); + JS::Heap* asHeapT = reinterpret_cast*>(v); + aCallbacks.Trace(asHeapT, aName, aClosure); +} + +} +} + + + +namespace mozilla { + +template +inline void +Swap(JS::Heap& aX, JS::Heap& aY) +{ + T tmp = aX; + aX = aY; + aY = tmp; +} + +template +inline void +Swap(JS::TenuredHeap& aX, JS::TenuredHeap& aY) +{ + T tmp = aX; + aX = aY; + aY = tmp; +} + +} + +namespace js { +namespace detail { +# 1320 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" +template +struct DefineComparisonOps : mozilla::FalseType {}; + +template +struct DefineComparisonOps> : mozilla::TrueType { + static const T& get(const JS::Heap& v) { return v.unbarrieredGet(); } +}; + +template +struct DefineComparisonOps> : mozilla::TrueType { + static const T get(const JS::TenuredHeap& v) { return v.unbarrieredGetPtr(); } +}; + +template <> +struct DefineComparisonOps : mozilla::TrueType { + static const JSObject* get(const JS::ObjectPtr& v) { return v.unbarrieredGet(); } +}; + +template +struct DefineComparisonOps> : mozilla::TrueType { + static const T& get(const JS::Rooted& v) { return v.get(); } +}; + +template +struct DefineComparisonOps> : mozilla::TrueType { + static const T& get(const JS::Handle& v) { return v.get(); } +}; + +template +struct DefineComparisonOps> : mozilla::TrueType { + static const T& get(const JS::MutableHandle& v) { return v.get(); } +}; + +template +struct DefineComparisonOps> : mozilla::TrueType { + static const T& get(const JS::PersistentRooted& v) { return v.get(); } +}; + +template +struct DefineComparisonOps> : mozilla::TrueType { + static const T& get(const js::FakeRooted& v) { return v.get(); } +}; + +template +struct DefineComparisonOps> : mozilla::TrueType { + static const T& get(const js::FakeMutableHandle& v) { return v.get(); } +}; + +} +} +# 1378 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" +template +typename mozilla::EnableIf::value && + js::detail::DefineComparisonOps::value, bool>::Type +operator==(const T& a, const U& b) { + return js::detail::DefineComparisonOps::get(a) == js::detail::DefineComparisonOps::get(b); +} + +template +typename mozilla::EnableIf::value && + js::detail::DefineComparisonOps::value, bool>::Type +operator!=(const T& a, const U& b) { + return !(a == b); +} + + + +template +typename mozilla::EnableIf::value, bool>::Type +operator==(const T& a, const typename T::ElementType& b) { + return js::detail::DefineComparisonOps::get(a) == b; +} + +template +typename mozilla::EnableIf::value, bool>::Type +operator!=(const T& a, const typename T::ElementType& b) { + return !(a == b); +} + +template +typename mozilla::EnableIf::value, bool>::Type +operator==(const typename T::ElementType& a, const T& b) { + return a == js::detail::DefineComparisonOps::get(b); +} + +template +typename mozilla::EnableIf::value, bool>::Type +operator!=(const typename T::ElementType& a, const T& b) { + return !(a == b); +} + + + + +template +typename mozilla::EnableIf::value && + mozilla::IsPointer::value, bool>::Type +operator==(const typename mozilla::RemovePointer::Type* a, const T& b) { + return a == js::detail::DefineComparisonOps::get(b); +} + +template +typename mozilla::EnableIf::value && + mozilla::IsPointer::value, bool>::Type +operator!=(const typename mozilla::RemovePointer::Type* a, const T& b) { + return !(a == b); +} + +template +typename mozilla::EnableIf::value && + mozilla::IsPointer::value, bool>::Type +operator==(const T& a, const typename mozilla::RemovePointer::Type* b) { + return js::detail::DefineComparisonOps::get(a) == b; +} + +template +typename mozilla::EnableIf::value && + mozilla::IsPointer::value, bool>::Type +operator!=(const T& a, const typename mozilla::RemovePointer::Type* b) { + return !(a == b); +} + + + +template +typename mozilla::EnableIf::value && + mozilla::IsPointer::value, bool>::Type +operator==(std::nullptr_t a, const T& b) { + return a == js::detail::DefineComparisonOps::get(b); +} + +template +typename mozilla::EnableIf::value && + mozilla::IsPointer::value, bool>::Type +operator!=(std::nullptr_t a, const T& b) { + return !(a == b); +} + +template +typename mozilla::EnableIf::value && + mozilla::IsPointer::value, bool>::Type +operator==(const T& a, std::nullptr_t b) { + return js::detail::DefineComparisonOps::get(a) == b; +} + +template +typename mozilla::EnableIf::value && + mozilla::IsPointer::value, bool>::Type +operator!=(const T& a, std::nullptr_t b) { + return !(a == b); +} +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h" 2 +# 41 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h" +class nsCycleCollectionISupports +{ +public: + template struct COMTypeInfo; +}; + +template struct nsCycleCollectionISupports::COMTypeInfo { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template const nsIID nsCycleCollectionISupports::COMTypeInfo::kIID __attribute__ ((visibility ("hidden"))) = { 0xc61eac14, 0x5f7a, 0x4481, { 0x96, 0x5e, 0x7e, 0xaa, 0x6e, 0xff, 0xa8, 0x5f } }; + + +namespace JS { +template class Heap; +} + + + + + + +struct TraceCallbacks +{ + virtual void Trace(JS::Heap* aPtr, const char* aName, + void* aClosure) const = 0; + virtual void Trace(JS::Heap* aPtr, const char* aName, + void* aClosure) const = 0; + virtual void Trace(JS::Heap* aPtr, const char* aName, + void* aClosure) const = 0; + virtual void Trace(JSObject** aPtr, const char* aName, + void* aClosure) const = 0; + virtual void Trace(JS::TenuredHeap* aPtr, const char* aName, + void* aClosure) const = 0; + virtual void Trace(JS::Heap* aPtr, const char* aName, + void* aClosure) const = 0; + virtual void Trace(JS::Heap* aPtr, const char* aName, + void* aClosure) const = 0; + virtual void Trace(JS::Heap* aPtr, const char* aName, + void* aClosure) const = 0; +}; + + + + + +struct TraceCallbackFunc : public TraceCallbacks +{ + typedef void (*Func)(JS::GCCellPtr aPtr, const char* aName, void* aClosure); + + explicit TraceCallbackFunc(Func aCb) : mCallback(aCb) {} + + virtual void Trace(JS::Heap* aPtr, const char* aName, + void* aClosure) const override; + virtual void Trace(JS::Heap* aPtr, const char* aName, + void* aClosure) const override; + virtual void Trace(JS::Heap* aPtr, const char* aName, + void* aClosure) const override; + virtual void Trace(JSObject** aPtr, const char* aName, + void* aClosure) const override; + virtual void Trace(JS::TenuredHeap* aPtr, const char* aName, + void* aClosure) const override; + virtual void Trace(JS::Heap* aPtr, const char* aName, + void* aClosure) const override; + virtual void Trace(JS::Heap* aPtr, const char* aName, + void* aClosure) const override; + virtual void Trace(JS::Heap* aPtr, const char* aName, + void* aClosure) const override; + +private: + Func mCallback; +}; + + + + +class nsCycleCollectionParticipant +{ +public: + constexpr explicit nsCycleCollectionParticipant(bool aSkip, + bool aTraverseShouldTrace = false) + : mMightSkip(aSkip) + , mTraverseShouldTrace(aTraverseShouldTrace) + { + } + + virtual nsresult TraverseNative(void* aPtr, nsCycleCollectionTraversalCallback& aCb) = 0; + + nsresult TraverseNativeAndJS(void* aPtr, + nsCycleCollectionTraversalCallback& aCb) + { + nsresult rv = TraverseNative(aPtr, aCb); + if (mTraverseShouldTrace) { + + + TraceCallbackFunc noteJsChild(&nsCycleCollectionParticipant::NoteJSChild); + Trace(aPtr, noteJsChild, &aCb); + } + return rv; + } + + + static void NoteJSChild(JS::GCCellPtr aGCThing, const char* aName, + void* aClosure); + + virtual void Root(void* aPtr) = 0; + virtual void Unlink(void* aPtr) = 0; + virtual void Unroot(void* aPtr) = 0; + virtual const char* ClassName() = 0; + + virtual void Trace(void* aPtr, const TraceCallbacks& aCb, + void* aClosure) {} +# 163 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h" + bool CanSkip(void* aPtr, bool aRemovingAllowed) + { + return mMightSkip ? CanSkipReal(aPtr, aRemovingAllowed) : false; + } +# 193 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h" + bool CanSkipInCC(void* aPtr) + { + return mMightSkip ? CanSkipInCCReal(aPtr) : false; + } +# 213 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h" + bool CanSkipThis(void* aPtr) + { + return mMightSkip ? CanSkipThisReal(aPtr) : false; + } + + virtual void DeleteCycleCollectable(void* aPtr) = 0; + +protected: + virtual bool CanSkipReal(void* aPtr, bool aRemovingAllowed) + { + do { } while(0); + return false; + } + virtual bool CanSkipInCCReal(void* aPtr) + { + do { } while(0); + return false; + } + virtual bool CanSkipThisReal(void* aPtr) + { + do { } while(0); + return false; + } + +private: + const bool mMightSkip; + const bool mTraverseShouldTrace; +}; + +class nsScriptObjectTracer : public nsCycleCollectionParticipant +{ +public: + constexpr explicit nsScriptObjectTracer(bool aSkip) + : nsCycleCollectionParticipant(aSkip, true) + { + } + + virtual void Trace(void* aPtr, const TraceCallbacks& aCb, + void* aClosure) override = 0; + +}; + +class nsXPCOMCycleCollectionParticipant : public nsScriptObjectTracer +{ +public: + constexpr explicit nsXPCOMCycleCollectionParticipant(bool aSkip) + : nsScriptObjectTracer(aSkip) + { + } + + template struct COMTypeInfo; + + virtual void Root(void* aPtr) override; + virtual void Unroot(void* aPtr) override; + + virtual void Trace(void* aPtr, const TraceCallbacks& aCb, + void* aClosure) override; + + static bool CheckForRightISupports(nsISupports* aSupports); +}; + +template struct nsXPCOMCycleCollectionParticipant::COMTypeInfo { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template const nsIID nsXPCOMCycleCollectionParticipant::COMTypeInfo::kIID __attribute__ ((visibility ("hidden"))) = { 0x9674489b, 0x1f6f, 0x4550, { 0xa7, 0x30, 0xcc, 0xae, 0xdd, 0x10, 0x4c, 0xf9 } }; +# 341 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h" +template::value> +struct DowncastCCParticipantImpl +{ +}; + + +template +struct DowncastCCParticipantImpl +{ + static T* Run(void* aPtr) + { + nsISupports* s = static_cast(aPtr); + do { } while (0); + + T* rval = T::cycleCollection::Downcast(s); + ; + return rval; + } +}; + + +template +struct DowncastCCParticipantImpl +{ + static T* Run(void* aPtr) { return static_cast(aPtr); } +}; + +template +T* +DowncastCCParticipant(void* aPtr) +{ + return DowncastCCParticipantImpl::Run(aPtr); +} +# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NameSpaceConstants.h" 1 +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NameSpaceConstants.h" +static const int32_t kNameSpaceID_None = 0; +# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringGlue.h" 1 +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringGlue.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 1 +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstring.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstring.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 1 +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringFwd.h" 1 +# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringFwd.h" +namespace mozilla { +namespace detail { + +class nsStringRepr; +class nsCStringRepr; + +} +} + + + + + +class nsAString; +class nsSubstringTuple; +class nsString; +class nsAutoString; +class nsDependentString; +class nsDependentSubstring; +class nsPromiseFlatString; +class nsStringComparator; +class nsDefaultStringComparator; +class nsXPIDLString; + + + + + + +class nsACString; +class nsCSubstringTuple; +class nsCString; +class nsAutoCString; +class nsDependentCString; +class nsDependentCSubstring; +class nsPromiseFlatCString; +class nsCStringComparator; +class nsDefaultCStringComparator; +class nsXPIDLCString; + + + + + + +typedef nsAString nsSubstring; +typedef nsACString nsCSubstring; + +typedef nsString nsAFlatString; +typedef nsSubstring nsASingleFragmentString; + +typedef nsCString nsAFlatCString; +typedef nsCSubstring nsASingleFragmentCString; +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringIterator.h" 1 +# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringIterator.h" +template +class nsReadingIterator +{ +public: + typedef nsReadingIterator self_type; + typedef ptrdiff_t difference_type; + typedef size_t size_type; + typedef CharT value_type; + typedef const CharT* pointer; + typedef const CharT& reference; + +private: + friend class mozilla::detail::nsStringRepr; + friend class mozilla::detail::nsCStringRepr; + + + + + + + const CharT* mStart; + const CharT* mEnd; + const CharT* mPosition; + +public: + nsReadingIterator() + { + } + + + + pointer get() const + { + return mPosition; + } + + CharT operator*() const + { + return *get(); + } + + self_type& operator++() + { + ++mPosition; + return *this; + } + + self_type operator++(int) + { + self_type result(*this); + ++mPosition; + return result; + } + + self_type& operator--() + { + --mPosition; + return *this; + } + + self_type operator--(int) + { + self_type result(*this); + --mPosition; + return result; + } + + self_type& advance(difference_type aN) + { + if (aN > 0) { + difference_type step = XPCOM_MIN(aN, mEnd - mPosition); + + do { } while(0); + + + mPosition += step; + } else if (aN < 0) { + difference_type step = XPCOM_MAX(aN, -(mPosition - mStart)); + + do { } while(0); + + + mPosition += step; + } + return *this; + } + + + + + + + size_type operator-(const self_type& aOther) const + { + do { } while (0); + return mPosition - aOther.mPosition; + } +}; + + + + + +template +class nsWritingIterator +{ +public: + typedef nsWritingIterator self_type; + typedef ptrdiff_t difference_type; + typedef size_t size_type; + typedef CharT value_type; + typedef CharT* pointer; + typedef CharT& reference; + +private: + friend class nsAString; + friend class nsACString; + + + + + + + CharT* mStart; + CharT* mEnd; + CharT* mPosition; + +public: + nsWritingIterator() + { + } + + + + pointer get() const + { + return mPosition; + } + + reference operator*() const + { + return *get(); + } + + self_type& operator++() + { + ++mPosition; + return *this; + } + + self_type operator++(int) + { + self_type result(*this); + ++mPosition; + return result; + } + + self_type& operator--() + { + --mPosition; + return *this; + } + + self_type operator--(int) + { + self_type result(*this); + --mPosition; + return result; + } + + self_type& advance(difference_type aN) + { + if (aN > 0) { + difference_type step = XPCOM_MIN(aN, mEnd - mPosition); + + do { } while(0); + + + mPosition += step; + } else if (aN < 0) { + difference_type step = XPCOM_MAX(aN, -(mPosition - mStart)); + + do { } while(0); + + + mPosition += step; + } + return *this; + } + + + + + + + size_type operator-(const self_type& aOther) const + { + do { } while (0); + return mPosition - aOther.mPosition; + } +}; + +template +struct nsCharSinkTraits> +{ + static void + write(nsWritingIterator& aIter, const CharT* aStr, uint32_t aN) + { + nsCharTraits::move(aIter.get(), aStr, aN); + aIter.advance(aN); + } +}; + +template +inline bool +operator==(const nsReadingIterator& aLhs, + const nsReadingIterator& aRhs) +{ + return aLhs.get() == aRhs.get(); +} + +template +inline bool +operator!=(const nsReadingIterator& aLhs, + const nsReadingIterator& aRhs) +{ + return aLhs.get() != aRhs.get(); +} + + + + + + +template +inline bool +operator==(const nsWritingIterator& aLhs, + const nsWritingIterator& aRhs) +{ + return aLhs.get() == aRhs.get(); +} + +template +inline bool +operator!=(const nsWritingIterator& aLhs, + const nsWritingIterator& aRhs) +{ + return aLhs.get() != aRhs.get(); +} +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2 + + + + + + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1 +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" 1 + + + + + + + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IntegerPrintfMacros.h" 1 +# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IntegerPrintfMacros.h" +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/inttypes.h" 1 3 +# 30 "/usr/local/bin/../lib/clang/3.9.1/include/inttypes.h" 3 +# 1 "/usr/include/inttypes.h" 1 3 4 +# 266 "/usr/include/inttypes.h" 3 4 +extern "C" { + + + + +typedef struct + { + long int quot; + long int rem; + } imaxdiv_t; +# 290 "/usr/include/inttypes.h" 3 4 +extern intmax_t imaxabs (intmax_t __n) throw () __attribute__ ((__const__)); + + +extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom) + throw () __attribute__ ((__const__)); + + +extern intmax_t strtoimax (const char *__restrict __nptr, + char **__restrict __endptr, int __base) throw (); + + +extern uintmax_t strtoumax (const char *__restrict __nptr, + char ** __restrict __endptr, int __base) throw (); + + +extern intmax_t wcstoimax (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + throw (); + + +extern uintmax_t wcstoumax (const wchar_t *__restrict __nptr, + wchar_t ** __restrict __endptr, int __base) + throw (); +# 432 "/usr/include/inttypes.h" 3 4 +} +# 31 "/usr/local/bin/../lib/clang/3.9.1/include/inttypes.h" 2 3 +# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IntegerPrintfMacros.h" 2 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" 2 +# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" +class nsStringComparator +{ +public: + typedef char16_t char_type; + + nsStringComparator() + { + } + + virtual int operator()(const char_type*, const char_type*, + uint32_t, uint32_t) const = 0; +}; + + + + + +class nsDefaultStringComparator + : public nsStringComparator +{ +public: + typedef char16_t char_type; + + nsDefaultStringComparator() + { + } + + virtual int operator()(const char_type*, const char_type*, + uint32_t, uint32_t) const override; +}; + +class nsSubstringSplitter; + +namespace mozilla { +namespace detail { +# 75 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" +class nsStringRepr +{ +public: + typedef mozilla::fallible_t fallible_t; + + typedef char16_t char_type; + + typedef nsCharTraits char_traits; + typedef char_traits::incompatible_char_type incompatible_char_type; + + typedef nsStringRepr self_type; + typedef self_type base_string_type; + + typedef nsAString substring_type; + typedef nsSubstringTuple substring_tuple_type; + typedef nsString string_type; + + typedef nsReadingIterator const_iterator; + typedef nsWritingIterator iterator; + + typedef nsStringComparator comparator_type; + + typedef char_type* char_iterator; + typedef const char_type* const_char_iterator; + + typedef uint32_t index_type; + typedef uint32_t size_type; + + + + + + const_char_iterator BeginReading() const + { + return mData; + } + const_char_iterator EndReading() const + { + return mData + mLength; + } + + + + + + const_iterator& BeginReading(const_iterator& aIter) const + { + aIter.mStart = mData; + aIter.mEnd = mData + mLength; + aIter.mPosition = aIter.mStart; + return aIter; + } + + const_iterator& EndReading(const_iterator& aIter) const + { + aIter.mStart = mData; + aIter.mEnd = mData + mLength; + aIter.mPosition = aIter.mEnd; + return aIter; + } + + const_char_iterator& BeginReading(const_char_iterator& aIter) const + { + return aIter = mData; + } + + const_char_iterator& EndReading(const_char_iterator& aIter) const + { + return aIter = mData + mLength; + } +# 154 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + const char_type* Data() const + + { + return mData; + } + + size_type Length() const + { + return mLength; + } + + uint32_t Flags() const + { + return mFlags; + } + + bool IsEmpty() const + { + return mLength == 0; + } + + bool IsLiteral() const + { + return (mFlags & F_LITERAL) != 0; + } + + bool IsVoid() const + { + return (mFlags & F_VOIDED) != 0; + } + + bool IsTerminated() const + { + return (mFlags & F_TERMINATED) != 0; + } + + char_type CharAt(index_type aIndex) const + { + do { } while(0); + return mData[aIndex]; + } + + char_type operator[](index_type aIndex) const + { + return CharAt(aIndex); + } + + char_type First() const; + + char_type Last() const; + + size_type CountChar(char_type) const; + int32_t FindChar(char_type, index_type aOffset = 0) const; + + inline bool Contains(char_type aChar) const + { + return FindChar(aChar) != -1; + } + + + + + + bool Equals(const self_type&) const; + bool Equals(const self_type&, const comparator_type&) const; + + bool Equals(const substring_tuple_type& aTuple) const; + bool Equals(const substring_tuple_type& aTuple, + const comparator_type& aComp) const; + + bool Equals(const char_type* aData) const; + bool Equals(const char_type* aData, + const comparator_type& aComp) const; +# 244 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + bool EqualsASCII(const char* aData, size_type aLen) const; + + + + + + bool EqualsASCII(const char* aData) const; + + + + + + + + template + inline bool EqualsLiteral(const char (&aStr)[N]) const + { + return EqualsASCII(aStr, N - 1); + } + + + + + + + + bool LowerCaseEqualsASCII(const char* aData, + size_type aLen) const; + bool LowerCaseEqualsASCII(const char* aData) const; + + + + + + + template + inline bool LowerCaseEqualsLiteral(const char (&aStr)[N]) const + { + return LowerCaseEqualsASCII(aStr, N - 1); + } + + + + + bool IsDependentOn(const char_type* aStart, const char_type* aEnd) const + { +# 298 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + return (aStart < (mData + mLength) && aEnd > mData); + } + +protected: + nsStringRepr() = delete; + + constexpr + nsStringRepr(char_type* aData, size_type aLength, uint32_t aFlags) + : mData(aData) + , mLength(aLength) + , mFlags(aFlags) + { + } + + char_type* mData; + size_type mLength; + uint32_t mFlags; + +public: + + + + + + + enum + { + F_NONE = 0, + + + F_TERMINATED = 1 << 0, + F_VOIDED = 1 << 1, + F_SHARED = 1 << 2, + F_OWNED = 1 << 3, + F_FIXED = 1 << 4, + F_LITERAL = 1 << 5, + + + F_CLASS_FIXED = 1 << 16 + }; +# 372 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" +}; + +} +} +# 389 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" +class nsAString : public mozilla::detail::nsStringRepr +{ +public: + typedef nsAString self_type; + + + ~nsAString() + { + Finalize(); + } + + + + + + char_iterator BeginWriting() + { + if (!EnsureMutable()) { + AllocFailed(mLength); + } + + return mData; + } + + char_iterator BeginWriting(const fallible_t&) + { + return EnsureMutable() ? mData : char_iterator(0); + } + + char_iterator EndWriting() + { + if (!EnsureMutable()) { + AllocFailed(mLength); + } + + return mData + mLength; + } + + char_iterator EndWriting(const fallible_t&) + { + return EnsureMutable() ? (mData + mLength) : char_iterator(0); + } + + char_iterator& BeginWriting(char_iterator& aIter) + { + return aIter = BeginWriting(); + } + + char_iterator& BeginWriting(char_iterator& aIter, const fallible_t& aFallible) + { + return aIter = BeginWriting(aFallible); + } + + char_iterator& EndWriting(char_iterator& aIter) + { + return aIter = EndWriting(); + } + + char_iterator& EndWriting(char_iterator& aIter, const fallible_t& aFallible) + { + return aIter = EndWriting(aFallible); + } + + + + + + iterator& BeginWriting(iterator& aIter) + { + char_type* data = BeginWriting(); + aIter.mStart = data; + aIter.mEnd = data + mLength; + aIter.mPosition = aIter.mStart; + return aIter; + } + + iterator& EndWriting(iterator& aIter) + { + char_type* data = BeginWriting(); + aIter.mStart = data; + aIter.mEnd = data + mLength; + aIter.mPosition = aIter.mEnd; + return aIter; + } + + + + + + void Assign(char_type aChar); + __attribute__ ((warn_unused_result)) bool Assign(char_type aChar, const fallible_t&); + + void Assign(const char_type* aData); + __attribute__ ((warn_unused_result)) bool Assign(const char_type* aData, + const fallible_t&); + + void Assign(const char_type* aData, size_type aLength); + __attribute__ ((warn_unused_result)) bool Assign(const char_type* aData, + size_type aLength, const fallible_t&); + + void Assign(const self_type&); + __attribute__ ((warn_unused_result)) bool Assign(const self_type&, const fallible_t&); + + void Assign(const substring_tuple_type&); + __attribute__ ((warn_unused_result)) bool Assign(const substring_tuple_type&, + const fallible_t&); +# 515 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + void AssignASCII(const char* aData, size_type aLength); + __attribute__ ((warn_unused_result)) bool AssignASCII(const char* aData, + size_type aLength, + const fallible_t&); + + void AssignASCII(const char* aData) + { + AssignASCII(aData, mozilla::AssertedCast(strlen(aData))); + } + __attribute__ ((warn_unused_result)) bool AssignASCII(const char* aData, + const fallible_t& aFallible) + { + return AssignASCII(aData, + mozilla::AssertedCast(strlen(aData)), + aFallible); + } + + + + + + + + template + void AssignLiteral(const char_type (&aStr)[N]) + { + AssignLiteral(aStr, N - 1); + } + + template + void AssignLiteral(const char (&aStr)[N]) + { + AssignASCII(aStr, N - 1); + } + + + self_type& operator=(char_type aChar) + { + Assign(aChar); + return *this; + } + self_type& operator=(const char_type* aData) + { + Assign(aData); + return *this; + } + + + + + + + + self_type& operator=(const self_type& aStr) + { + Assign(aStr); + return *this; + } + self_type& operator=(const substring_tuple_type& aTuple) + { + Assign(aTuple); + return *this; + } + + void Adopt(char_type* aData, size_type aLength = size_type(-1)); + + + + + + + void Replace(index_type aCutStart, size_type aCutLength, + char_type aChar); + __attribute__ ((warn_unused_result)) bool Replace(index_type aCutStart, + size_type aCutLength, + char_type aChar, + const fallible_t&); + void Replace(index_type aCutStart, size_type aCutLength, + const char_type* aData, + size_type aLength = size_type(-1)); + __attribute__ ((warn_unused_result)) bool Replace(index_type aCutStart, + size_type aCutLength, + const char_type* aData, + size_type aLength, + const fallible_t&); + void Replace(index_type aCutStart, size_type aCutLength, + const self_type& aStr) + { + Replace(aCutStart, aCutLength, aStr.Data(), aStr.Length()); + } + __attribute__ ((warn_unused_result)) bool Replace(index_type aCutStart, + size_type aCutLength, + const self_type& aStr, + const fallible_t& aFallible) + { + return Replace(aCutStart, aCutLength, aStr.Data(), aStr.Length(), + aFallible); + } + void Replace(index_type aCutStart, size_type aCutLength, + const substring_tuple_type& aTuple); + + void ReplaceASCII(index_type aCutStart, size_type aCutLength, + const char* aData, + size_type aLength = size_type(-1)); + + __attribute__ ((warn_unused_result)) bool ReplaceASCII(index_type aCutStart, size_type aCutLength, + const char* aData, + size_type aLength, + const fallible_t&); + + + + + template + void ReplaceLiteral(index_type aCutStart, size_type aCutLength, + const char_type (&aStr)[N]) + { + ReplaceLiteral(aCutStart, aCutLength, aStr, N - 1); + } + + void Append(char_type aChar) + { + Replace(mLength, 0, aChar); + } + __attribute__ ((warn_unused_result)) bool Append(char_type aChar, const fallible_t& aFallible) + { + return Replace(mLength, 0, aChar, aFallible); + } + void Append(const char_type* aData, size_type aLength = size_type(-1)) + { + Replace(mLength, 0, aData, aLength); + } + __attribute__ ((warn_unused_result)) bool Append(const char_type* aData, size_type aLength, + const fallible_t& aFallible) + { + return Replace(mLength, 0, aData, aLength, aFallible); + } +# 660 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + void Append(const self_type& aStr) + { + Replace(mLength, 0, aStr); + } + __attribute__ ((warn_unused_result)) bool Append(const self_type& aStr, const fallible_t& aFallible) + { + return Replace(mLength, 0, aStr, aFallible); + } + void Append(const substring_tuple_type& aTuple) + { + Replace(mLength, 0, aTuple); + } + + void AppendASCII(const char* aData, size_type aLength = size_type(-1)) + { + ReplaceASCII(mLength, 0, aData, aLength); + } + + __attribute__ ((warn_unused_result)) bool AppendASCII(const char* aData, const fallible_t& aFallible) + { + return ReplaceASCII(mLength, 0, aData, size_type(-1), aFallible); + } + + __attribute__ ((warn_unused_result)) bool AppendASCII(const char* aData, size_type aLength, const fallible_t& aFallible) + { + return ReplaceASCII(mLength, 0, aData, aLength, aFallible); + } + + + + + + + + void AppendPrintf(const char* aFormat, ...) __attribute__ ((format (printf, 2, 3))); + void AppendPrintf(const char* aFormat, va_list aAp); + void AppendInt(int32_t aInteger) + { + AppendPrintf("%" "d", aInteger); + } + void AppendInt(int32_t aInteger, int aRadix) + { + if (aRadix == 10) { + AppendPrintf("%" "d", aInteger); + } else { + AppendPrintf(aRadix == 8 ? "%" "o" : "%" "x", + static_cast(aInteger)); + } + } + void AppendInt(uint32_t aInteger) + { + AppendPrintf("%" "u", aInteger); + } + void AppendInt(uint32_t aInteger, int aRadix) + { + AppendPrintf(aRadix == 10 ? "%" "u" : aRadix == 8 ? "%" "o" : "%" "x", + aInteger); + } + void AppendInt(int64_t aInteger) + { + AppendPrintf("%" "l" "d", aInteger); + } + void AppendInt(int64_t aInteger, int aRadix) + { + if (aRadix == 10) { + AppendPrintf("%" "l" "d", aInteger); + } else { + AppendPrintf(aRadix == 8 ? "%" "l" "o" : "%" "l" "x", + static_cast(aInteger)); + } + } + void AppendInt(uint64_t aInteger) + { + AppendPrintf("%" "l" "u", aInteger); + } + void AppendInt(uint64_t aInteger, int aRadix) + { + AppendPrintf(aRadix == 10 ? "%" "l" "u" : aRadix == 8 ? "%" "l" "o" : "%" "l" "x", + aInteger); + } + + + + + void AppendFloat(float aFloat); + void AppendFloat(double aFloat); +public: + + + + + template + void AppendLiteral(const char_type (&aStr)[N]) + { + ReplaceLiteral(mLength, 0, aStr, N - 1); + } + + template + void AppendLiteral(const char (&aStr)[N]) + { + AppendASCII(aStr, N - 1); + } + + template + __attribute__ ((warn_unused_result)) bool AppendLiteral(const char (&aStr)[N], const fallible_t& aFallible) + { + return AppendASCII(aStr, N - 1, aFallible); + } + + + self_type& operator+=(char_type aChar) + { + Append(aChar); + return *this; + } + self_type& operator+=(const char_type* aData) + { + Append(aData); + return *this; + } + + + + + + + + self_type& operator+=(const self_type& aStr) + { + Append(aStr); + return *this; + } + self_type& operator+=(const substring_tuple_type& aTuple) + { + Append(aTuple); + return *this; + } + + void Insert(char_type aChar, index_type aPos) + { + Replace(aPos, 0, aChar); + } + void Insert(const char_type* aData, index_type aPos, + size_type aLength = size_type(-1)) + { + Replace(aPos, 0, aData, aLength); + } + + + + + + + + void Insert(const self_type& aStr, index_type aPos) + { + Replace(aPos, 0, aStr); + } + void Insert(const substring_tuple_type& aTuple, index_type aPos) + { + Replace(aPos, 0, aTuple); + } + + + + + template + void InsertLiteral(const char_type (&aStr)[N], index_type aPos) + { + ReplaceLiteral(aPos, 0, aStr, N - 1); + } + + void Cut(index_type aCutStart, size_type aCutLength) + { + Replace(aCutStart, aCutLength, char_traits::sEmptyBuffer, 0); + } + + nsSubstringSplitter Split(const char_type aChar) const; +# 850 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + void SetCapacity(size_type aNewCapacity); + __attribute__ ((warn_unused_result)) bool SetCapacity(size_type aNewCapacity, + const fallible_t&); + + void SetLength(size_type aNewLength); + __attribute__ ((warn_unused_result)) bool SetLength(size_type aNewLength, + const fallible_t&); + + void Truncate(size_type aNewLength = 0) + { + do { } while(0); + SetLength(aNewLength); + } +# 876 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + inline size_type GetData(const char_type** aData) const + { + *aData = mData; + return mLength; + } +# 892 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + size_type GetMutableData(char_type** aData, size_type aNewLen = size_type(-1)) + { + if (!EnsureMutable(aNewLen)) { + AllocFailed(aNewLen == size_type(-1) ? mLength : aNewLen); + } + + *aData = mData; + return mLength; + } + + size_type GetMutableData(char_type** aData, size_type aNewLen, const fallible_t&) + { + if (!EnsureMutable(aNewLen)) { + *aData = nullptr; + return 0; + } + + *aData = mData; + return mLength; + } +# 931 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + operator mozilla::Span() + { + return mozilla::MakeSpan(BeginWriting(), Length()); + } + + operator mozilla::Span() const + { + return mozilla::MakeSpan(BeginReading(), Length()); + } + + void Append(mozilla::Span aSpan) + { + auto len = aSpan.Length(); + do { static_assert(mozilla::detail::AssertionConditionType::value)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(len <= mozilla::MaxValue::value))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "len <= mozilla::MaxValue::value" ")"); do { *((volatile int*) __null) = 944; ::abort(); } while (0); } } while (0); + Append(aSpan.Elements(), len); + } + + __attribute__ ((warn_unused_result)) bool Append(mozilla::Span aSpan, + const fallible_t& aFallible) + { + auto len = aSpan.Length(); + if (len > mozilla::MaxValue::value) { + return false; + } + return Append(aSpan.Elements(), len, aFallible); + } +# 995 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + void SetIsVoid(bool); +# 1005 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + void StripChar(char_type aChar, int32_t aOffset = 0); +# 1015 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + void StripChars(const char_type* aChars, uint32_t aOffset = 0); + + + + + + void ForgetSharedBuffer() + { + if (mFlags & nsSubstring::F_SHARED) { + mData = char_traits::sEmptyBuffer; + mLength = 0; + mFlags = F_TERMINATED; + } + } + +public: + + + + + + nsAString(const substring_tuple_type& aTuple) + : nsStringRepr(nullptr, 0, F_NONE) + { + Assign(aTuple); + } + + size_t SizeOfExcludingThisIfUnshared(mozilla::MallocSizeOf aMallocSizeOf) + const; + size_t SizeOfIncludingThisIfUnshared(mozilla::MallocSizeOf aMallocSizeOf) + const; + + + + + + + + size_t SizeOfExcludingThisEvenIfShared(mozilla::MallocSizeOf aMallocSizeOf) + const; + size_t SizeOfIncludingThisEvenIfShared(mozilla::MallocSizeOf aMallocSizeOf) + const; + + template + void NS_ABORT_OOM(T) + { + struct never {}; + static_assert(mozilla::IsSame::value, + "In string classes, use AllocFailed to account for sizeof(char_type). " + "Use the global ::NS_ABORT_OOM if you really have a count of bytes."); + } + + __attribute__((always_inline)) inline void AllocFailed(size_t aLength) + { + ::NS_ABORT_OOM(aLength * sizeof(char_type)); + } + +protected: + + + nsAString() + : nsStringRepr(char_traits::sEmptyBuffer, 0, F_TERMINATED) + { + } + + + + nsAString(const self_type& aStr) + : nsStringRepr(aStr.mData, aStr.mLength, + aStr.mFlags & (F_TERMINATED | F_VOIDED)) + { + } +# 1097 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + nsAString(char_type* aData, size_type aLength, uint32_t aFlags) + : nsStringRepr(aData, aLength, aFlags) + { + } + + + + + + + + void Finalize(); +# 1128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + bool MutatePrep(size_type aCapacity, + char_type** aOldData, uint32_t* aOldFlags); +# 1151 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + __attribute__ ((warn_unused_result)) bool ReplacePrep(index_type aCutStart, + size_type aCutLength, + size_type aNewLength); + + __attribute__ ((warn_unused_result)) bool ReplacePrepInternal( + index_type aCutStart, + size_type aCutLength, + size_type aNewFragLength, + size_type aNewTotalLength); +# 1168 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + size_type Capacity() const; + + + + + + __attribute__ ((warn_unused_result)) bool EnsureMutable( + size_type aNewLen = size_type(-1)); + + + + + static __attribute__ ((warn_unused_result)) bool CheckCapacity(size_type aCapacity) { + if (aCapacity > kMaxCapacity) { + + + do { } while(0); + return false; + } + + return true; + } + + + + + void SetDataFlags(uint32_t aDataFlags) + { + do { } while(0); + mFlags = aDataFlags | (mFlags & 0xFFFF0000); + } + + void ReplaceLiteral(index_type aCutStart, size_type aCutLength, + const char_type* aData, size_type aLength); + + static const size_type kMaxCapacity; +public: + + + + void AssignLiteral(const char_type* aData, size_type aLength); +}; + +static_assert(sizeof(nsAString) == + sizeof(mozilla::detail::nsStringRepr), + "Don't add new data fields to nsTSubstring_CharT. " + "Add to nsTStringRepr_CharT instead."); + +int +Compare(const nsAString::base_string_type& aLhs, + const nsAString::base_string_type& aRhs, + const nsStringComparator& = nsDefaultStringComparator()); + + +inline bool +operator!=(const nsAString::base_string_type& aLhs, + const nsAString::base_string_type& aRhs) +{ + return !aLhs.Equals(aRhs); +} + +inline bool +operator!=(const nsAString::base_string_type& aLhs, + const nsAString::char_type* aRhs) +{ + return !aLhs.Equals(aRhs); +} + +inline bool +operator<(const nsAString::base_string_type& aLhs, + const nsAString::base_string_type& aRhs) +{ + return Compare(aLhs, aRhs) < 0; +} + +inline bool +operator<=(const nsAString::base_string_type& aLhs, + const nsAString::base_string_type& aRhs) +{ + return Compare(aLhs, aRhs) <= 0; +} + +inline bool +operator==(const nsAString::base_string_type& aLhs, + const nsAString::base_string_type& aRhs) +{ + return aLhs.Equals(aRhs); +} + +inline bool +operator==(const nsAString::base_string_type& aLhs, + const nsAString::char_type* aRhs) +{ + return aLhs.Equals(aRhs); +} + + +inline bool +operator>=(const nsAString::base_string_type& aLhs, + const nsAString::base_string_type& aRhs) +{ + return Compare(aLhs, aRhs) >= 0; +} + +inline bool +operator>(const nsAString::base_string_type& aLhs, + const nsAString::base_string_type& aRhs) +{ + return Compare(aLhs, aRhs) > 0; +} + + + +class nsSubstringSplitter +{ + typedef nsAString::size_type size_type; + typedef nsAString::char_type char_type; + + class nsTSubstringSplit_Iter + { + public: + nsTSubstringSplit_Iter(const nsSubstringSplitter& aObj, + size_type aPos) + : mObj(aObj) + , mPos(aPos) + { + } + + bool operator!=(const nsTSubstringSplit_Iter& other) const + { + return mPos != other.mPos; + } + + const nsDependentSubstring& operator*() const; + + const nsTSubstringSplit_Iter& operator++() + { + ++mPos; + return *this; + } + + private: + const nsSubstringSplitter& mObj; + size_type mPos; + }; + +private: + const nsAString* const mStr; + mozilla::UniquePtr mArray; + size_type mArraySize; + const char_type mDelim; + +public: + nsSubstringSplitter(const nsAString* aStr, char_type aDelim); + + nsTSubstringSplit_Iter begin() const + { + return nsTSubstringSplit_Iter(*this, 0); + } + + nsTSubstringSplit_Iter end() const + { + return nsTSubstringSplit_Iter(*this, mArraySize); + } + + const nsDependentSubstring& Get(const size_type index) const + { + do { } while (0); + return mArray[index]; + } +}; + + + + +namespace mozilla { + +inline Span +MakeSpan(nsAString& aString) +{ + return aString; +} + +inline Span +MakeSpan(const nsAString& aString) +{ + return aString; +} + +} +# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1 +# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2 + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1 +# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" 1 +# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" +class nsCStringComparator +{ +public: + typedef char char_type; + + nsCStringComparator() + { + } + + virtual int operator()(const char_type*, const char_type*, + uint32_t, uint32_t) const = 0; +}; + + + + + +class nsDefaultCStringComparator + : public nsCStringComparator +{ +public: + typedef char char_type; + + nsDefaultCStringComparator() + { + } + + virtual int operator()(const char_type*, const char_type*, + uint32_t, uint32_t) const override; +}; + +class nsCSubstringSplitter; + +namespace mozilla { +namespace detail { +# 75 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" +class nsCStringRepr +{ +public: + typedef mozilla::fallible_t fallible_t; + + typedef char char_type; + + typedef nsCharTraits char_traits; + typedef char_traits::incompatible_char_type incompatible_char_type; + + typedef nsCStringRepr self_type; + typedef self_type base_string_type; + + typedef nsACString substring_type; + typedef nsCSubstringTuple substring_tuple_type; + typedef nsCString string_type; + + typedef nsReadingIterator const_iterator; + typedef nsWritingIterator iterator; + + typedef nsCStringComparator comparator_type; + + typedef char_type* char_iterator; + typedef const char_type* const_char_iterator; + + typedef uint32_t index_type; + typedef uint32_t size_type; + + + + + + const_char_iterator BeginReading() const + { + return mData; + } + const_char_iterator EndReading() const + { + return mData + mLength; + } + + + + + + const_iterator& BeginReading(const_iterator& aIter) const + { + aIter.mStart = mData; + aIter.mEnd = mData + mLength; + aIter.mPosition = aIter.mStart; + return aIter; + } + + const_iterator& EndReading(const_iterator& aIter) const + { + aIter.mStart = mData; + aIter.mEnd = mData + mLength; + aIter.mPosition = aIter.mEnd; + return aIter; + } + + const_char_iterator& BeginReading(const_char_iterator& aIter) const + { + return aIter = mData; + } + + const_char_iterator& EndReading(const_char_iterator& aIter) const + { + return aIter = mData + mLength; + } +# 154 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + const char_type* Data() const + + { + return mData; + } + + size_type Length() const + { + return mLength; + } + + uint32_t Flags() const + { + return mFlags; + } + + bool IsEmpty() const + { + return mLength == 0; + } + + bool IsLiteral() const + { + return (mFlags & F_LITERAL) != 0; + } + + bool IsVoid() const + { + return (mFlags & F_VOIDED) != 0; + } + + bool IsTerminated() const + { + return (mFlags & F_TERMINATED) != 0; + } + + char_type CharAt(index_type aIndex) const + { + do { } while(0); + return mData[aIndex]; + } + + char_type operator[](index_type aIndex) const + { + return CharAt(aIndex); + } + + char_type First() const; + + char_type Last() const; + + size_type CountChar(char_type) const; + int32_t FindChar(char_type, index_type aOffset = 0) const; + + inline bool Contains(char_type aChar) const + { + return FindChar(aChar) != -1; + } + + + + + + bool Equals(const self_type&) const; + bool Equals(const self_type&, const comparator_type&) const; + + bool Equals(const substring_tuple_type& aTuple) const; + bool Equals(const substring_tuple_type& aTuple, + const comparator_type& aComp) const; + + bool Equals(const char_type* aData) const; + bool Equals(const char_type* aData, + const comparator_type& aComp) const; +# 244 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + bool EqualsASCII(const char* aData, size_type aLen) const; + + + + + + bool EqualsASCII(const char* aData) const; + + + + + + + + template + inline bool EqualsLiteral(const char (&aStr)[N]) const + { + return EqualsASCII(aStr, N - 1); + } + + + + + + + + bool LowerCaseEqualsASCII(const char* aData, + size_type aLen) const; + bool LowerCaseEqualsASCII(const char* aData) const; + + + + + + + template + inline bool LowerCaseEqualsLiteral(const char (&aStr)[N]) const + { + return LowerCaseEqualsASCII(aStr, N - 1); + } + + + + + bool IsDependentOn(const char_type* aStart, const char_type* aEnd) const + { +# 298 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + return (aStart < (mData + mLength) && aEnd > mData); + } + +protected: + nsCStringRepr() = delete; + + constexpr + nsCStringRepr(char_type* aData, size_type aLength, uint32_t aFlags) + : mData(aData) + , mLength(aLength) + , mFlags(aFlags) + { + } + + char_type* mData; + size_type mLength; + uint32_t mFlags; + +public: + + + + + + + enum + { + F_NONE = 0, + + + F_TERMINATED = 1 << 0, + F_VOIDED = 1 << 1, + F_SHARED = 1 << 2, + F_OWNED = 1 << 3, + F_FIXED = 1 << 4, + F_LITERAL = 1 << 5, + + + F_CLASS_FIXED = 1 << 16 + }; +# 372 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" +}; + +} +} +# 389 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" +class nsACString : public mozilla::detail::nsCStringRepr +{ +public: + typedef nsACString self_type; + + + ~nsACString() + { + Finalize(); + } + + + + + + char_iterator BeginWriting() + { + if (!EnsureMutable()) { + AllocFailed(mLength); + } + + return mData; + } + + char_iterator BeginWriting(const fallible_t&) + { + return EnsureMutable() ? mData : char_iterator(0); + } + + char_iterator EndWriting() + { + if (!EnsureMutable()) { + AllocFailed(mLength); + } + + return mData + mLength; + } + + char_iterator EndWriting(const fallible_t&) + { + return EnsureMutable() ? (mData + mLength) : char_iterator(0); + } + + char_iterator& BeginWriting(char_iterator& aIter) + { + return aIter = BeginWriting(); + } + + char_iterator& BeginWriting(char_iterator& aIter, const fallible_t& aFallible) + { + return aIter = BeginWriting(aFallible); + } + + char_iterator& EndWriting(char_iterator& aIter) + { + return aIter = EndWriting(); + } + + char_iterator& EndWriting(char_iterator& aIter, const fallible_t& aFallible) + { + return aIter = EndWriting(aFallible); + } + + + + + + iterator& BeginWriting(iterator& aIter) + { + char_type* data = BeginWriting(); + aIter.mStart = data; + aIter.mEnd = data + mLength; + aIter.mPosition = aIter.mStart; + return aIter; + } + + iterator& EndWriting(iterator& aIter) + { + char_type* data = BeginWriting(); + aIter.mStart = data; + aIter.mEnd = data + mLength; + aIter.mPosition = aIter.mEnd; + return aIter; + } + + + + + + void Assign(char_type aChar); + __attribute__ ((warn_unused_result)) bool Assign(char_type aChar, const fallible_t&); + + void Assign(const char_type* aData); + __attribute__ ((warn_unused_result)) bool Assign(const char_type* aData, + const fallible_t&); + + void Assign(const char_type* aData, size_type aLength); + __attribute__ ((warn_unused_result)) bool Assign(const char_type* aData, + size_type aLength, const fallible_t&); + + void Assign(const self_type&); + __attribute__ ((warn_unused_result)) bool Assign(const self_type&, const fallible_t&); + + void Assign(const substring_tuple_type&); + __attribute__ ((warn_unused_result)) bool Assign(const substring_tuple_type&, + const fallible_t&); +# 515 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + void AssignASCII(const char* aData, size_type aLength); + __attribute__ ((warn_unused_result)) bool AssignASCII(const char* aData, + size_type aLength, + const fallible_t&); + + void AssignASCII(const char* aData) + { + AssignASCII(aData, mozilla::AssertedCast(strlen(aData))); + } + __attribute__ ((warn_unused_result)) bool AssignASCII(const char* aData, + const fallible_t& aFallible) + { + return AssignASCII(aData, + mozilla::AssertedCast(strlen(aData)), + aFallible); + } + + + + + + + + template + void AssignLiteral(const char_type (&aStr)[N]) + { + AssignLiteral(aStr, N - 1); + } +# 551 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + self_type& operator=(char_type aChar) + { + Assign(aChar); + return *this; + } + self_type& operator=(const char_type* aData) + { + Assign(aData); + return *this; + } + + + + + + + + self_type& operator=(const self_type& aStr) + { + Assign(aStr); + return *this; + } + self_type& operator=(const substring_tuple_type& aTuple) + { + Assign(aTuple); + return *this; + } + + void Adopt(char_type* aData, size_type aLength = size_type(-1)); + + + + + + + void Replace(index_type aCutStart, size_type aCutLength, + char_type aChar); + __attribute__ ((warn_unused_result)) bool Replace(index_type aCutStart, + size_type aCutLength, + char_type aChar, + const fallible_t&); + void Replace(index_type aCutStart, size_type aCutLength, + const char_type* aData, + size_type aLength = size_type(-1)); + __attribute__ ((warn_unused_result)) bool Replace(index_type aCutStart, + size_type aCutLength, + const char_type* aData, + size_type aLength, + const fallible_t&); + void Replace(index_type aCutStart, size_type aCutLength, + const self_type& aStr) + { + Replace(aCutStart, aCutLength, aStr.Data(), aStr.Length()); + } + __attribute__ ((warn_unused_result)) bool Replace(index_type aCutStart, + size_type aCutLength, + const self_type& aStr, + const fallible_t& aFallible) + { + return Replace(aCutStart, aCutLength, aStr.Data(), aStr.Length(), + aFallible); + } + void Replace(index_type aCutStart, size_type aCutLength, + const substring_tuple_type& aTuple); + + void ReplaceASCII(index_type aCutStart, size_type aCutLength, + const char* aData, + size_type aLength = size_type(-1)); + + __attribute__ ((warn_unused_result)) bool ReplaceASCII(index_type aCutStart, size_type aCutLength, + const char* aData, + size_type aLength, + const fallible_t&); + + + + + template + void ReplaceLiteral(index_type aCutStart, size_type aCutLength, + const char_type (&aStr)[N]) + { + ReplaceLiteral(aCutStart, aCutLength, aStr, N - 1); + } + + void Append(char_type aChar) + { + Replace(mLength, 0, aChar); + } + __attribute__ ((warn_unused_result)) bool Append(char_type aChar, const fallible_t& aFallible) + { + return Replace(mLength, 0, aChar, aFallible); + } + void Append(const char_type* aData, size_type aLength = size_type(-1)) + { + Replace(mLength, 0, aData, aLength); + } + __attribute__ ((warn_unused_result)) bool Append(const char_type* aData, size_type aLength, + const fallible_t& aFallible) + { + return Replace(mLength, 0, aData, aLength, aFallible); + } +# 660 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + void Append(const self_type& aStr) + { + Replace(mLength, 0, aStr); + } + __attribute__ ((warn_unused_result)) bool Append(const self_type& aStr, const fallible_t& aFallible) + { + return Replace(mLength, 0, aStr, aFallible); + } + void Append(const substring_tuple_type& aTuple) + { + Replace(mLength, 0, aTuple); + } + + void AppendASCII(const char* aData, size_type aLength = size_type(-1)) + { + ReplaceASCII(mLength, 0, aData, aLength); + } + + __attribute__ ((warn_unused_result)) bool AppendASCII(const char* aData, const fallible_t& aFallible) + { + return ReplaceASCII(mLength, 0, aData, size_type(-1), aFallible); + } + + __attribute__ ((warn_unused_result)) bool AppendASCII(const char* aData, size_type aLength, const fallible_t& aFallible) + { + return ReplaceASCII(mLength, 0, aData, aLength, aFallible); + } + + + + + + + + void AppendPrintf(const char* aFormat, ...) __attribute__ ((format (printf, 2, 3))); + void AppendPrintf(const char* aFormat, va_list aAp); + void AppendInt(int32_t aInteger) + { + AppendPrintf("%" "d", aInteger); + } + void AppendInt(int32_t aInteger, int aRadix) + { + if (aRadix == 10) { + AppendPrintf("%" "d", aInteger); + } else { + AppendPrintf(aRadix == 8 ? "%" "o" : "%" "x", + static_cast(aInteger)); + } + } + void AppendInt(uint32_t aInteger) + { + AppendPrintf("%" "u", aInteger); + } + void AppendInt(uint32_t aInteger, int aRadix) + { + AppendPrintf(aRadix == 10 ? "%" "u" : aRadix == 8 ? "%" "o" : "%" "x", + aInteger); + } + void AppendInt(int64_t aInteger) + { + AppendPrintf("%" "l" "d", aInteger); + } + void AppendInt(int64_t aInteger, int aRadix) + { + if (aRadix == 10) { + AppendPrintf("%" "l" "d", aInteger); + } else { + AppendPrintf(aRadix == 8 ? "%" "l" "o" : "%" "l" "x", + static_cast(aInteger)); + } + } + void AppendInt(uint64_t aInteger) + { + AppendPrintf("%" "l" "u", aInteger); + } + void AppendInt(uint64_t aInteger, int aRadix) + { + AppendPrintf(aRadix == 10 ? "%" "l" "u" : aRadix == 8 ? "%" "l" "o" : "%" "l" "x", + aInteger); + } + + + + + void AppendFloat(float aFloat); + void AppendFloat(double aFloat); +public: + + + + + template + void AppendLiteral(const char_type (&aStr)[N]) + { + ReplaceLiteral(mLength, 0, aStr, N - 1); + } +# 770 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + self_type& operator+=(char_type aChar) + { + Append(aChar); + return *this; + } + self_type& operator+=(const char_type* aData) + { + Append(aData); + return *this; + } + + + + + + + + self_type& operator+=(const self_type& aStr) + { + Append(aStr); + return *this; + } + self_type& operator+=(const substring_tuple_type& aTuple) + { + Append(aTuple); + return *this; + } + + void Insert(char_type aChar, index_type aPos) + { + Replace(aPos, 0, aChar); + } + void Insert(const char_type* aData, index_type aPos, + size_type aLength = size_type(-1)) + { + Replace(aPos, 0, aData, aLength); + } + + + + + + + + void Insert(const self_type& aStr, index_type aPos) + { + Replace(aPos, 0, aStr); + } + void Insert(const substring_tuple_type& aTuple, index_type aPos) + { + Replace(aPos, 0, aTuple); + } + + + + + template + void InsertLiteral(const char_type (&aStr)[N], index_type aPos) + { + ReplaceLiteral(aPos, 0, aStr, N - 1); + } + + void Cut(index_type aCutStart, size_type aCutLength) + { + Replace(aCutStart, aCutLength, char_traits::sEmptyBuffer, 0); + } + + nsCSubstringSplitter Split(const char_type aChar) const; +# 850 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + void SetCapacity(size_type aNewCapacity); + __attribute__ ((warn_unused_result)) bool SetCapacity(size_type aNewCapacity, + const fallible_t&); + + void SetLength(size_type aNewLength); + __attribute__ ((warn_unused_result)) bool SetLength(size_type aNewLength, + const fallible_t&); + + void Truncate(size_type aNewLength = 0) + { + do { } while(0); + SetLength(aNewLength); + } +# 876 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + inline size_type GetData(const char_type** aData) const + { + *aData = mData; + return mLength; + } +# 892 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + size_type GetMutableData(char_type** aData, size_type aNewLen = size_type(-1)) + { + if (!EnsureMutable(aNewLen)) { + AllocFailed(aNewLen == size_type(-1) ? mLength : aNewLen); + } + + *aData = mData; + return mLength; + } + + size_type GetMutableData(char_type** aData, size_type aNewLen, const fallible_t&) + { + if (!EnsureMutable(aNewLen)) { + *aData = nullptr; + return 0; + } + + *aData = mData; + return mLength; + } +# 931 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + operator mozilla::Span() + { + return mozilla::MakeSpan(BeginWriting(), Length()); + } + + operator mozilla::Span() const + { + return mozilla::MakeSpan(BeginReading(), Length()); + } + + void Append(mozilla::Span aSpan) + { + auto len = aSpan.Length(); + do { static_assert(mozilla::detail::AssertionConditionType::value)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(len <= mozilla::MaxValue::value))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "len <= mozilla::MaxValue::value" ")"); do { *((volatile int*) __null) = 944; ::abort(); } while (0); } } while (0); + Append(aSpan.Elements(), len); + } + + __attribute__ ((warn_unused_result)) bool Append(mozilla::Span aSpan, + const fallible_t& aFallible) + { + auto len = aSpan.Length(); + if (len > mozilla::MaxValue::value) { + return false; + } + return Append(aSpan.Elements(), len, aFallible); + } + + + operator mozilla::Span() + { + return mozilla::MakeSpan(reinterpret_cast(BeginWriting()), + Length()); + } + + operator mozilla::Span() const + { + return mozilla::MakeSpan(reinterpret_cast(BeginReading()), + Length()); + } + + void Append(mozilla::Span aSpan) + { + auto len = aSpan.Length(); + do { static_assert(mozilla::detail::AssertionConditionType::value)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(len <= mozilla::MaxValue::value))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "len <= mozilla::MaxValue::value" ")"); do { *((volatile int*) __null) = 974; ::abort(); } while (0); } } while (0); + Append(reinterpret_cast(aSpan.Elements()), len); + } + + __attribute__ ((warn_unused_result)) bool Append(mozilla::Span aSpan, + const fallible_t& aFallible) + { + auto len = aSpan.Length(); + if (len > mozilla::MaxValue::value) { + return false; + } + return Append( + reinterpret_cast(aSpan.Elements()), len, aFallible); + } + + + + + + + + void SetIsVoid(bool); +# 1005 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + void StripChar(char_type aChar, int32_t aOffset = 0); +# 1015 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + void StripChars(const char_type* aChars, uint32_t aOffset = 0); + + + + + + void ForgetSharedBuffer() + { + if (mFlags & nsSubstring::F_SHARED) { + mData = char_traits::sEmptyBuffer; + mLength = 0; + mFlags = F_TERMINATED; + } + } + +public: + + + + + + nsACString(const substring_tuple_type& aTuple) + : nsCStringRepr(nullptr, 0, F_NONE) + { + Assign(aTuple); + } + + size_t SizeOfExcludingThisIfUnshared(mozilla::MallocSizeOf aMallocSizeOf) + const; + size_t SizeOfIncludingThisIfUnshared(mozilla::MallocSizeOf aMallocSizeOf) + const; + + + + + + + + size_t SizeOfExcludingThisEvenIfShared(mozilla::MallocSizeOf aMallocSizeOf) + const; + size_t SizeOfIncludingThisEvenIfShared(mozilla::MallocSizeOf aMallocSizeOf) + const; + + template + void NS_ABORT_OOM(T) + { + struct never {}; + static_assert(mozilla::IsSame::value, + "In string classes, use AllocFailed to account for sizeof(char_type). " + "Use the global ::NS_ABORT_OOM if you really have a count of bytes."); + } + + __attribute__((always_inline)) inline void AllocFailed(size_t aLength) + { + ::NS_ABORT_OOM(aLength * sizeof(char_type)); + } + +protected: + + + nsACString() + : nsCStringRepr(char_traits::sEmptyBuffer, 0, F_TERMINATED) + { + } + + + + nsACString(const self_type& aStr) + : nsCStringRepr(aStr.mData, aStr.mLength, + aStr.mFlags & (F_TERMINATED | F_VOIDED)) + { + } +# 1097 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + nsACString(char_type* aData, size_type aLength, uint32_t aFlags) + : nsCStringRepr(aData, aLength, aFlags) + { + } + + + + + + + + void Finalize(); +# 1128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + bool MutatePrep(size_type aCapacity, + char_type** aOldData, uint32_t* aOldFlags); +# 1151 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + __attribute__ ((warn_unused_result)) bool ReplacePrep(index_type aCutStart, + size_type aCutLength, + size_type aNewLength); + + __attribute__ ((warn_unused_result)) bool ReplacePrepInternal( + index_type aCutStart, + size_type aCutLength, + size_type aNewFragLength, + size_type aNewTotalLength); +# 1168 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" + size_type Capacity() const; + + + + + + __attribute__ ((warn_unused_result)) bool EnsureMutable( + size_type aNewLen = size_type(-1)); + + + + + static __attribute__ ((warn_unused_result)) bool CheckCapacity(size_type aCapacity) { + if (aCapacity > kMaxCapacity) { + + + do { } while(0); + return false; + } + + return true; + } + + + + + void SetDataFlags(uint32_t aDataFlags) + { + do { } while(0); + mFlags = aDataFlags | (mFlags & 0xFFFF0000); + } + + void ReplaceLiteral(index_type aCutStart, size_type aCutLength, + const char_type* aData, size_type aLength); + + static const size_type kMaxCapacity; +public: + + + + void AssignLiteral(const char_type* aData, size_type aLength); +}; + +static_assert(sizeof(nsACString) == + sizeof(mozilla::detail::nsCStringRepr), + "Don't add new data fields to nsTSubstring_CharT. " + "Add to nsTStringRepr_CharT instead."); + +int +Compare(const nsACString::base_string_type& aLhs, + const nsACString::base_string_type& aRhs, + const nsCStringComparator& = nsDefaultCStringComparator()); + + +inline bool +operator!=(const nsACString::base_string_type& aLhs, + const nsACString::base_string_type& aRhs) +{ + return !aLhs.Equals(aRhs); +} + +inline bool +operator!=(const nsACString::base_string_type& aLhs, + const nsACString::char_type* aRhs) +{ + return !aLhs.Equals(aRhs); +} + +inline bool +operator<(const nsACString::base_string_type& aLhs, + const nsACString::base_string_type& aRhs) +{ + return Compare(aLhs, aRhs) < 0; +} + +inline bool +operator<=(const nsACString::base_string_type& aLhs, + const nsACString::base_string_type& aRhs) +{ + return Compare(aLhs, aRhs) <= 0; +} + +inline bool +operator==(const nsACString::base_string_type& aLhs, + const nsACString::base_string_type& aRhs) +{ + return aLhs.Equals(aRhs); +} + +inline bool +operator==(const nsACString::base_string_type& aLhs, + const nsACString::char_type* aRhs) +{ + return aLhs.Equals(aRhs); +} + + +inline bool +operator>=(const nsACString::base_string_type& aLhs, + const nsACString::base_string_type& aRhs) +{ + return Compare(aLhs, aRhs) >= 0; +} + +inline bool +operator>(const nsACString::base_string_type& aLhs, + const nsACString::base_string_type& aRhs) +{ + return Compare(aLhs, aRhs) > 0; +} + + + +class nsCSubstringSplitter +{ + typedef nsACString::size_type size_type; + typedef nsACString::char_type char_type; + + class nsTSubstringSplit_Iter + { + public: + nsTSubstringSplit_Iter(const nsCSubstringSplitter& aObj, + size_type aPos) + : mObj(aObj) + , mPos(aPos) + { + } + + bool operator!=(const nsTSubstringSplit_Iter& other) const + { + return mPos != other.mPos; + } + + const nsDependentCSubstring& operator*() const; + + const nsTSubstringSplit_Iter& operator++() + { + ++mPos; + return *this; + } + + private: + const nsCSubstringSplitter& mObj; + size_type mPos; + }; + +private: + const nsACString* const mStr; + mozilla::UniquePtr mArray; + size_type mArraySize; + const char_type mDelim; + +public: + nsCSubstringSplitter(const nsACString* aStr, char_type aDelim); + + nsTSubstringSplit_Iter begin() const + { + return nsTSubstringSplit_Iter(*this, 0); + } + + nsTSubstringSplit_Iter end() const + { + return nsTSubstringSplit_Iter(*this, mArraySize); + } + + const nsDependentCSubstring& Get(const size_type index) const + { + do { } while (0); + return mArray[index]; + } +}; + + + + +namespace mozilla { + +inline Span +MakeSpan(nsACString& aString) +{ + return aString; +} + +inline Span +MakeSpan(const nsACString& aString) +{ + return aString; +} + +} +# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1 +# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2 + + + + + + +class nsCaseInsensitiveCStringComparator + : public nsCStringComparator +{ +public: + nsCaseInsensitiveCStringComparator() + { + } + typedef char char_type; + + virtual int operator()(const char_type*, const char_type*, + uint32_t, uint32_t) const override; +}; + +class nsCaseInsensitiveCStringArrayComparator +{ +public: + template + bool Equals(const A& aStrA, const B& aStrB) const + { + return aStrA.Equals(aStrB, nsCaseInsensitiveCStringComparator()); + } +}; + + + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstring.h" 1 +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2 + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1 +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstringTuple.h" 1 +# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstringTuple.h" +class nsSubstringTuple +{ +public: + + typedef char16_t char_type; + typedef nsCharTraits char_traits; + + typedef nsSubstringTuple self_type; + typedef mozilla::detail::nsStringRepr base_string_type; + typedef uint32_t size_type; + +public: + + nsSubstringTuple(const base_string_type* aStrA, + const base_string_type* aStrB) + : mHead(nullptr) + , mFragA(aStrA) + , mFragB(aStrB) + { + } + + nsSubstringTuple(const self_type& aHead, + const base_string_type* aStrB) + : mHead(&aHead) + , mFragA(nullptr) + , mFragB(aStrB) + { + } + + + + + size_type Length() const; + + + + + + + void WriteTo(char_type* aBuf, uint32_t aBufLen) const; + + + + + + bool IsDependentOn(const char_type* aStart, const char_type* aEnd) const; + +private: + + const self_type* const mHead; + const base_string_type* const mFragA; + const base_string_type* const mFragB; +}; + +inline const nsSubstringTuple +operator+(const nsSubstringTuple::base_string_type& aStrA, + const nsSubstringTuple::base_string_type& aStrB) +{ + return nsSubstringTuple(&aStrA, &aStrB); +} + +inline const nsSubstringTuple +operator+(const nsSubstringTuple& aHead, + const nsSubstringTuple::base_string_type& aStrB) +{ + return nsSubstringTuple(aHead, &aStrB); +} +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1 +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2 + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1 +# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstringTuple.h" 1 +# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstringTuple.h" +class nsCSubstringTuple +{ +public: + + typedef char char_type; + typedef nsCharTraits char_traits; + + typedef nsCSubstringTuple self_type; + typedef mozilla::detail::nsCStringRepr base_string_type; + typedef uint32_t size_type; + +public: + + nsCSubstringTuple(const base_string_type* aStrA, + const base_string_type* aStrB) + : mHead(nullptr) + , mFragA(aStrA) + , mFragB(aStrB) + { + } + + nsCSubstringTuple(const self_type& aHead, + const base_string_type* aStrB) + : mHead(&aHead) + , mFragA(nullptr) + , mFragB(aStrB) + { + } + + + + + size_type Length() const; + + + + + + + void WriteTo(char_type* aBuf, uint32_t aBufLen) const; + + + + + + bool IsDependentOn(const char_type* aStart, const char_type* aEnd) const; + +private: + + const self_type* const mHead; + const base_string_type* const mFragA; + const base_string_type* const mFragB; +}; + +inline const nsCSubstringTuple +operator+(const nsCSubstringTuple::base_string_type& aStrA, + const nsCSubstringTuple::base_string_type& aStrB) +{ + return nsCSubstringTuple(&aStrA, &aStrB); +} + +inline const nsCSubstringTuple +operator+(const nsCSubstringTuple& aHead, + const nsCSubstringTuple::base_string_type& aStrB) +{ + return nsCSubstringTuple(aHead, &aStrB); +} +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1 +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2 +# 60 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2 +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstring.h" 2 +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 1 +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1 +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentSubstring.h" 1 +# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentSubstring.h" +class nsDependentSubstring : public nsAString +{ +public: + + typedef nsDependentSubstring self_type; + +public: + + void Rebind(const substring_type&, uint32_t aStartPos, + uint32_t aLength = size_type(-1)); + + void Rebind(const char_type* aData, size_type aLength); + + void Rebind(const char_type* aStart, const char_type* aEnd); + + nsDependentSubstring(const substring_type& aStr, uint32_t aStartPos, + uint32_t aLength = size_type(-1)) + : substring_type() + { + Rebind(aStr, aStartPos, aLength); + } + + nsDependentSubstring(const char_type* aData, size_type aLength) + : substring_type(const_cast(aData), aLength, F_NONE) + { + } + + nsDependentSubstring(const char_type* aStart, const char_type* aEnd); +# 57 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentSubstring.h" + nsDependentSubstring(const const_iterator& aStart, + const const_iterator& aEnd); + + + nsDependentSubstring() + : substring_type() + { + } + + + +private: + + void operator=(const self_type&); +}; + +inline const nsDependentSubstring +Substring(const nsAString& aStr, uint32_t aStartPos, + uint32_t aLength = uint32_t(-1)) +{ + return nsDependentSubstring(aStr, aStartPos, aLength); +} + +inline const nsDependentSubstring +Substring(const nsReadingIterator& aStart, + const nsReadingIterator& aEnd) +{ + return nsDependentSubstring(aStart.get(), aEnd.get()); +} + +inline const nsDependentSubstring +Substring(const char16_t* aData, uint32_t aLength) +{ + return nsDependentSubstring(aData, aLength); +} + +const nsDependentSubstring +Substring(const char16_t* aStart, const char16_t* aEnd); + +inline const nsDependentSubstring +StringHead(const nsAString& aStr, uint32_t aCount) +{ + return nsDependentSubstring(aStr, 0, aCount); +} + +inline const nsDependentSubstring +StringTail(const nsAString& aStr, uint32_t aCount) +{ + return nsDependentSubstring(aStr, aStr.Length() - aCount, aCount); +} +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1 +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 2 + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1 +# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentSubstring.h" 1 +# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentSubstring.h" +class nsDependentCSubstring : public nsACString +{ +public: + + typedef nsDependentCSubstring self_type; + +public: + + void Rebind(const substring_type&, uint32_t aStartPos, + uint32_t aLength = size_type(-1)); + + void Rebind(const char_type* aData, size_type aLength); + + void Rebind(const char_type* aStart, const char_type* aEnd); + + nsDependentCSubstring(const substring_type& aStr, uint32_t aStartPos, + uint32_t aLength = size_type(-1)) + : substring_type() + { + Rebind(aStr, aStartPos, aLength); + } + + nsDependentCSubstring(const char_type* aData, size_type aLength) + : substring_type(const_cast(aData), aLength, F_NONE) + { + } + + nsDependentCSubstring(const char_type* aStart, const char_type* aEnd); +# 57 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentSubstring.h" + nsDependentCSubstring(const const_iterator& aStart, + const const_iterator& aEnd); + + + nsDependentCSubstring() + : substring_type() + { + } + + + +private: + + void operator=(const self_type&); +}; + +inline const nsDependentCSubstring +Substring(const nsACString& aStr, uint32_t aStartPos, + uint32_t aLength = uint32_t(-1)) +{ + return nsDependentCSubstring(aStr, aStartPos, aLength); +} + +inline const nsDependentCSubstring +Substring(const nsReadingIterator& aStart, + const nsReadingIterator& aEnd) +{ + return nsDependentCSubstring(aStart.get(), aEnd.get()); +} + +inline const nsDependentCSubstring +Substring(const char* aData, uint32_t aLength) +{ + return nsDependentCSubstring(aData, aLength); +} + +const nsDependentCSubstring +Substring(const char* aStart, const char* aEnd); + +inline const nsDependentCSubstring +StringHead(const nsACString& aStr, uint32_t aCount) +{ + return nsDependentCSubstring(aStr, 0, aCount); +} + +inline const nsDependentCSubstring +StringTail(const nsACString& aStr, uint32_t aCount) +{ + return nsDependentCSubstring(aStr, aStr.Length() - aCount, aCount); +} +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1 +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 2 +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h" 1 +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h" +inline size_t +Distance(const nsReadingIterator& aStart, + const nsReadingIterator& aEnd) +{ + do { } while (0); + return static_cast(aEnd.get() - aStart.get()); +} +inline size_t +Distance(const nsReadingIterator& aStart, + const nsReadingIterator& aEnd) +{ + do { } while (0); + return static_cast(aEnd.get() - aStart.get()); +} + +void LossyCopyUTF16toASCII(const nsAString& aSource, nsACString& aDest); +void CopyASCIItoUTF16(const nsACString& aSource, nsAString& aDest); + +void LossyCopyUTF16toASCII(const char16ptr_t aSource, nsACString& aDest); +void CopyASCIItoUTF16(const char* aSource, nsAString& aDest); + +void CopyUTF16toUTF8(const nsAString& aSource, nsACString& aDest); +__attribute__ ((warn_unused_result)) bool CopyUTF16toUTF8(const nsAString& aSource, nsACString& aDest, + const mozilla::fallible_t&); +void CopyUTF8toUTF16(const nsACString& aSource, nsAString& aDest); + +void CopyUTF16toUTF8(const char16ptr_t aSource, nsACString& aDest); +void CopyUTF8toUTF16(const char* aSource, nsAString& aDest); + +void LossyAppendUTF16toASCII(const nsAString& aSource, nsACString& aDest); +void AppendASCIItoUTF16(const nsACString& aSource, nsAString& aDest); +__attribute__ ((warn_unused_result)) bool AppendASCIItoUTF16(const nsACString& aSource, + nsAString& aDest, + const mozilla::fallible_t&); + +void LossyAppendUTF16toASCII(const char16ptr_t aSource, nsACString& aDest); +__attribute__ ((warn_unused_result)) bool AppendASCIItoUTF16(const char* aSource, + nsAString& aDest, + const mozilla::fallible_t&); +void AppendASCIItoUTF16(const char* aSource, nsAString& aDest); + +void AppendUTF16toUTF8(const nsAString& aSource, nsACString& aDest); +__attribute__ ((warn_unused_result)) bool AppendUTF16toUTF8(const nsAString& aSource, + nsACString& aDest, + const mozilla::fallible_t&); +void AppendUTF8toUTF16(const nsACString& aSource, nsAString& aDest); +__attribute__ ((warn_unused_result)) bool AppendUTF8toUTF16(const nsACString& aSource, + nsAString& aDest, + const mozilla::fallible_t&); + +void AppendUTF16toUTF8(const char16ptr_t aSource, nsACString& aDest); +void AppendUTF8toUTF16(const char* aSource, nsAString& aDest); +# 85 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h" +char* ToNewCString(const nsAString& aSource); +# 97 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h" +char* ToNewCString(const nsACString& aSource); +# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h" +char* ToNewUTF8String(const nsAString& aSource, uint32_t* aUTF8Count = nullptr); +# 129 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h" +char16_t* ToNewUnicode(const nsAString& aSource); +# 143 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h" +char16_t* ToNewUnicode(const nsACString& aSource); +# 153 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h" +uint32_t CalcUTF8ToUnicodeLength(const nsACString& aSource); +# 173 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h" +char16_t* UTF8ToUnicodeBuffer(const nsACString& aSource, + char16_t* aBuffer, + uint32_t* aUTF16Count = nullptr); +# 192 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h" +char16_t* UTF8ToNewUnicode(const nsACString& aSource, + uint32_t* aUTF16Count = nullptr); +# 207 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h" +char16_t* CopyUnicodeTo(const nsAString& aSource, + uint32_t aSrcOffset, + char16_t* aDest, + uint32_t aLength); +# 224 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h" +void CopyUnicodeTo(const nsAString::const_iterator& aSrcStart, + const nsAString::const_iterator& aSrcEnd, + nsAString& aDest); +# 238 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h" +void AppendUnicodeTo(const nsAString::const_iterator& aSrcStart, + const nsAString::const_iterator& aSrcEnd, + nsAString& aDest); + + + + + + +bool IsASCII(const nsAString& aString); + + + + + + +bool IsASCII(const nsACString& aString); +# 287 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h" +bool IsUTF8(const nsACString& aString, bool aRejectNonChar = true); + +bool ParseString(const nsACString& aAstring, char aDelimiter, + nsTArray& aArray); + + + + +void ToUpperCase(nsACString&); + +void ToLowerCase(nsACString&); + +void ToUpperCase(nsCSubstring&); + +void ToLowerCase(nsCSubstring&); + + + + +void ToUpperCase(const nsACString& aSource, nsACString& aDest); + +void ToLowerCase(const nsACString& aSource, nsACString& aDest); +# 320 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h" +bool FindInReadable(const nsAString& aPattern, nsAString::const_iterator&, + nsAString::const_iterator&, + const nsStringComparator& = nsDefaultStringComparator()); +bool FindInReadable(const nsACString& aPattern, nsACString::const_iterator&, + nsACString::const_iterator&, + const nsCStringComparator& = nsDefaultCStringComparator()); + + + +inline bool +FindInReadable(const nsAString& aPattern, const nsAString& aSource, + const nsStringComparator& aCompare = nsDefaultStringComparator()) +{ + nsAString::const_iterator start, end; + aSource.BeginReading(start); + aSource.EndReading(end); + return FindInReadable(aPattern, start, end, aCompare); +} + +inline bool +FindInReadable(const nsACString& aPattern, const nsACString& aSource, + const nsCStringComparator& aCompare = nsDefaultCStringComparator()) +{ + nsACString::const_iterator start, end; + aSource.BeginReading(start); + aSource.EndReading(end); + return FindInReadable(aPattern, start, end, aCompare); +} + + +bool CaseInsensitiveFindInReadable(const nsACString& aPattern, + nsACString::const_iterator&, + nsACString::const_iterator&); + + + + + + + +bool RFindInReadable(const nsAString& aPattern, nsAString::const_iterator&, + nsAString::const_iterator&, + const nsStringComparator& = nsDefaultStringComparator()); +bool RFindInReadable(const nsACString& aPattern, nsACString::const_iterator&, + nsACString::const_iterator&, + const nsCStringComparator& = nsDefaultCStringComparator()); +# 375 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h" +bool FindCharInReadable(char16_t aChar, nsAString::const_iterator& aSearchStart, + const nsAString::const_iterator& aSearchEnd); +bool FindCharInReadable(char aChar, nsACString::const_iterator& aSearchStart, + const nsACString::const_iterator& aSearchEnd); + + + + +uint32_t CountCharInReadable(const nsAString& aStr, + char16_t aChar); +uint32_t CountCharInReadable(const nsACString& aStr, + char aChar); + +bool StringBeginsWith(const nsAString& aSource, const nsAString& aSubstring); +bool StringBeginsWith(const nsAString& aSource, const nsAString& aSubstring, + const nsStringComparator& aComparator); +bool StringBeginsWith(const nsACString& aSource, const nsACString& aSubstring); +bool StringBeginsWith(const nsACString& aSource, const nsACString& aSubstring, + const nsCStringComparator& aComparator); +bool StringEndsWith(const nsAString& aSource, const nsAString& aSubstring); +bool StringEndsWith(const nsAString& aSource, const nsAString& aSubstring, + const nsStringComparator& aComparator); +bool StringEndsWith(const nsACString& aSource, const nsACString& aSubstring); +bool StringEndsWith(const nsACString& aSource, const nsACString& aSubstring, + const nsCStringComparator& aComparator); + +const nsAFlatString& EmptyString(); +const nsAFlatCString& EmptyCString(); + +const nsAFlatString& NullString(); +const nsAFlatCString& NullCString(); +# 415 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h" +int32_t CompareUTF8toUTF16(const nsASingleFragmentCString& aUTF8String, + const nsASingleFragmentString& aUTF16String); + +void AppendUCS4ToUTF16(const uint32_t aSource, nsAString& aDest); + +template +inline bool +EnsureStringLength(T& aStr, uint32_t aLen) +{ + aStr.SetLength(aLen); + return (aStr.Length() == aLen); +} +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2 +# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1 +# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" 1 +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" +class nsString : public nsAString +{ +public: + + typedef nsString self_type; + +public: + + + + + + nsString() + : substring_type() + { + } + + explicit + nsString(const char_type* aData, size_type aLength = size_type(-1)) + : substring_type() + { + Assign(aData, aLength); + } +# 53 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + nsString(const self_type& aStr) + : substring_type() + { + Assign(aStr); + } + + nsString(const substring_tuple_type& aTuple) + : substring_type() + { + Assign(aTuple); + } + + explicit + nsString(const substring_type& aReadable) + : substring_type() + { + Assign(aReadable); + } + + + + self_type& operator=(char_type aChar) + { + Assign(aChar); + return *this; + } + self_type& operator=(const char_type* aData) + { + Assign(aData); + return *this; + } + self_type& operator=(const self_type& aStr) + { + Assign(aStr); + return *this; + } + + + + + + + + self_type& operator=(const substring_type& aStr) + { + Assign(aStr); + return *this; + } + self_type& operator=(const substring_tuple_type& aTuple) + { + Assign(aTuple); + return *this; + } +# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + const char_type* get() const + + { + return mData; + } +# 128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + char_type CharAt(index_type aIndex) const + { + do { } while(0); + return mData[aIndex]; + } + + char_type operator[](index_type aIndex) const + { + return CharAt(aIndex); + } +# 154 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + int32_t Find(const nsCString& aString, bool aIgnoreCase = false, + int32_t aOffset = 0, int32_t aCount = -1) const; + int32_t Find(const char* aString, bool aIgnoreCase = false, + int32_t aOffset = 0, int32_t aCount = -1) const; + + + int32_t Find(const nsAFlatString& aString, int32_t aOffset = 0, + int32_t aCount = -1) const; + int32_t Find(const char16_t* aString, int32_t aOffset = 0, + int32_t aCount = -1) const; +# 186 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + int32_t RFind(const nsCString& aString, bool aIgnoreCase = false, + int32_t aOffset = -1, int32_t aCount = -1) const; + int32_t RFind(const char* aCString, bool aIgnoreCase = false, + int32_t aOffset = -1, int32_t aCount = -1) const; + + + int32_t RFind(const nsAFlatString& aString, int32_t aOffset = -1, + int32_t aCount = -1) const; + int32_t RFind(const char16_t* aString, int32_t aOffset = -1, + int32_t aCount = -1) const; +# 210 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + int32_t RFindChar(char16_t aChar, int32_t aOffset = -1, + int32_t aCount = -1) const; +# 224 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + int32_t FindCharInSet(const char* aString, int32_t aOffset = 0) const; + int32_t FindCharInSet(const self_type& aString, int32_t aOffset = 0) const + { + return FindCharInSet(aString.get(), aOffset); + } + + + int32_t FindCharInSet(const char16_t* aString, int32_t aOffset = 0) const; +# 245 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + int32_t RFindCharInSet(const char_type* aString, int32_t aOffset = -1) const; + int32_t RFindCharInSet(const self_type& aString, int32_t aOffset = -1) const + { + return RFindCharInSet(aString.get(), aOffset); + } +# 281 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + bool EqualsIgnoreCase(const char* aString, int32_t aCount = -1) const; +# 292 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + double ToDouble(nsresult* aErrorCode) const; + + + + + + + + float ToFloat(nsresult* aErrorCode) const + { + return (float)ToDouble(aErrorCode); + } +# 312 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + int32_t ToInteger(nsresult* aErrorCode, uint32_t aRadix = (10)) const; + + + + + + + + int64_t ToInteger64(nsresult* aErrorCode, uint32_t aRadix = (10)) const; +# 340 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + size_type Mid(self_type& aResult, uint32_t aStartPos, uint32_t aCount) const; + + size_type Left(self_type& aResult, size_type aCount) const + { + return Mid(aResult, 0, aCount); + } + + size_type Right(self_type& aResult, size_type aCount) const + { + aCount = XPCOM_MIN(mLength, aCount); + return Mid(aResult, mLength - aCount, aCount); + } +# 362 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + bool SetCharAt(char16_t aChar, uint32_t aIndex); +# 372 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + using nsAString::StripChars; + + void StripChars(const char* aSet); + bool StripChars(const char* aSet, const fallible_t&); + + + + + + void StripWhitespace(); + bool StripWhitespace(const fallible_t&); + + + + + + + void ReplaceChar(char_type aOldChar, char_type aNewChar); + void ReplaceChar(const char* aSet, char_type aNewChar); + + void ReplaceChar(const char16_t* aSet, char16_t aNewChar); + + + + + + + void ReplaceSubstring(const self_type& aTarget, const self_type& aNewValue); + void ReplaceSubstring(const char_type* aTarget, const char_type* aNewValue); + __attribute__ ((warn_unused_result)) bool ReplaceSubstring(const self_type& aTarget, + const self_type& aNewValue, + const fallible_t&); + __attribute__ ((warn_unused_result)) bool ReplaceSubstring(const char_type* aTarget, + const char_type* aNewValue, + const fallible_t&); +# 419 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + void Trim(const char* aSet, bool aEliminateLeading = true, + bool aEliminateTrailing = true, bool aIgnoreQuotes = false); +# 430 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + void CompressWhitespace(bool aEliminateLeading = true, + bool aEliminateTrailing = true); + + + + + + + void AssignWithConversion(const nsACString& aString); + void AssignWithConversion(const incompatible_char_type* aData, + int32_t aLength = -1); +# 449 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + void Rebind(const char_type* aData, size_type aLength); + + + + + void AssertValidDependentString() + { + do { } while(0); + do { } while(0); + do { } while(0); + + + } + + +protected: + + + nsString(char_type* aData, size_type aLength, uint32_t aFlags) + : substring_type(aData, aLength, aFlags) + { + } + + struct Segment { + uint32_t mBegin, mLength; + Segment(uint32_t aBegin, uint32_t aLength) + : mBegin(aBegin) + , mLength(aLength) + {} + }; +}; + + +class nsFixedString : public nsString +{ +public: + + typedef nsFixedString self_type; + typedef nsFixedString fixed_string_type; + +public: +# 501 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + nsFixedString(char_type* aData, size_type aStorageSize) + : string_type(aData, uint32_t(char_traits::length(aData)), + F_TERMINATED | F_FIXED | F_CLASS_FIXED) + , mFixedCapacity(aStorageSize - 1) + , mFixedBuf(aData) + { + } + + nsFixedString(char_type* aData, size_type aStorageSize, + size_type aLength) + : string_type(aData, aLength, F_TERMINATED | F_FIXED | F_CLASS_FIXED) + , mFixedCapacity(aStorageSize - 1) + , mFixedBuf(aData) + { + + mFixedBuf[aLength] = char_type(0); + } + + + self_type& operator=(char_type aChar) + { + Assign(aChar); + return *this; + } + self_type& operator=(const char_type* aData) + { + Assign(aData); + return *this; + } + self_type& operator=(const substring_type& aStr) + { + Assign(aStr); + return *this; + } + self_type& operator=(const substring_tuple_type& aTuple) + { + Assign(aTuple); + return *this; + } + +protected: + + friend class nsAString; + + size_type mFixedCapacity; + char_type* mFixedBuf; +}; +# 562 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" +class nsAutoString : public nsFixedString +{ +public: + + typedef nsAutoString self_type; + +public: + + + + + + nsAutoString() + : fixed_string_type(mStorage, kDefaultStorageSize, 0) + { + } + + explicit + nsAutoString(char_type aChar) + : fixed_string_type(mStorage, kDefaultStorageSize, 0) + { + Assign(aChar); + } + + explicit + nsAutoString(const char_type* aData, size_type aLength = size_type(-1)) + : fixed_string_type(mStorage, kDefaultStorageSize, 0) + { + Assign(aData, aLength); + } +# 601 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + nsAutoString(const self_type& aStr) + : fixed_string_type(mStorage, kDefaultStorageSize, 0) + { + Assign(aStr); + } + + explicit + nsAutoString(const substring_type& aStr) + : fixed_string_type(mStorage, kDefaultStorageSize, 0) + { + Assign(aStr); + } + + nsAutoString(const substring_tuple_type& aTuple) + : fixed_string_type(mStorage, kDefaultStorageSize, 0) + { + Assign(aTuple); + } + + + self_type& operator=(char_type aChar) + { + Assign(aChar); + return *this; + } + self_type& operator=(const char_type* aData) + { + Assign(aData); + return *this; + } + + + + + + + + self_type& operator=(const self_type& aStr) + { + Assign(aStr); + return *this; + } + self_type& operator=(const substring_type& aStr) + { + Assign(aStr); + return *this; + } + self_type& operator=(const substring_tuple_type& aTuple) + { + Assign(aTuple); + return *this; + } + + enum + { + kDefaultStorageSize = 64 + }; + +private: + + char_type mStorage[kDefaultStorageSize]; +}; + + + + + + + +template class nsTArrayElementTraits; +template<> +class nsTArrayElementTraits +{ +public: + template struct Dont_Instantiate_nsTArray_of; + template struct Instead_Use_nsTArray_of; + + static Dont_Instantiate_nsTArray_of* + Construct(Instead_Use_nsTArray_of* aE) + { + return 0; + } + template + static Dont_Instantiate_nsTArray_of* + Construct(Instead_Use_nsTArray_of* aE, const A& aArg) + { + return 0; + } + static Dont_Instantiate_nsTArray_of* + Destruct(Instead_Use_nsTArray_of* aE) + { + return 0; + } +}; +# 708 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" +class nsXPIDLString : public nsString +{ +public: + + typedef nsXPIDLString self_type; + +public: + + nsXPIDLString() + : string_type(char_traits::sEmptyBuffer, 0, F_TERMINATED | F_VOIDED) + { + } + + + nsXPIDLString(const self_type& aStr) + : string_type(char_traits::sEmptyBuffer, 0, F_TERMINATED | F_VOIDED) + { + Assign(aStr); + } + + + + + + const char_type* get() const + + { + return (mFlags & F_VOIDED) ? nullptr : mData; + } + + + + operator const char_type*() const + { + return get(); + } + + + char_type operator[](int32_t aIndex) const + { + return CharAt(index_type(aIndex)); + } + + + self_type& operator=(char_type aChar) + { + Assign(aChar); + return *this; + } + self_type& operator=(const char_type* aStr) + { + Assign(aStr); + return *this; + } + self_type& operator=(const self_type& aStr) + { + Assign(aStr); + return *this; + } + self_type& operator=(const substring_type& aStr) + { + Assign(aStr); + return *this; + } + self_type& operator=(const substring_tuple_type& aTuple) + { + Assign(aTuple); + return *this; + } +}; +# 792 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" +class nsGetterCopies +{ +public: + typedef char16_t char_type; + + explicit nsGetterCopies(nsAString& aStr) + : mString(aStr) + , mData(nullptr) + { + } + + ~nsGetterCopies() + { + mString.Adopt(mData); + } + + operator char_type**() + { + return &mData; + } + +private: + nsAString& mString; + char_type* mData; +}; + +inline nsGetterCopies +getter_Copies(nsAString& aString) +{ + return nsGetterCopies(aString); +} +# 833 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" +class nsAdoptingString : public nsXPIDLString +{ +public: + + typedef nsAdoptingString self_type; + +public: + + explicit nsAdoptingString() + { + } + explicit nsAdoptingString(char_type* aStr, + size_type aLength = size_type(-1)) + { + Adopt(aStr, aLength); + } + + + + + + nsAdoptingString(const self_type& aStr) + : nsXPIDLString() + { + *this = aStr; + } + + + self_type& operator=(const substring_type& aStr) + { + Assign(aStr); + return *this; + } + self_type& operator=(const substring_tuple_type& aTuple) + { + Assign(aTuple); + return *this; + } + + + + + self_type& operator=(const self_type& aStr); + +private: + self_type& operator=(const char_type* aData) = delete; + self_type& operator=(char_type* aData) = delete; +}; +# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1 +# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2 + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1 +# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" 1 +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" +class nsCString : public nsACString +{ +public: + + typedef nsCString self_type; + +public: + + + + + + nsCString() + : substring_type() + { + } + + explicit + nsCString(const char_type* aData, size_type aLength = size_type(-1)) + : substring_type() + { + Assign(aData, aLength); + } +# 53 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + nsCString(const self_type& aStr) + : substring_type() + { + Assign(aStr); + } + + nsCString(const substring_tuple_type& aTuple) + : substring_type() + { + Assign(aTuple); + } + + explicit + nsCString(const substring_type& aReadable) + : substring_type() + { + Assign(aReadable); + } + + + + self_type& operator=(char_type aChar) + { + Assign(aChar); + return *this; + } + self_type& operator=(const char_type* aData) + { + Assign(aData); + return *this; + } + self_type& operator=(const self_type& aStr) + { + Assign(aStr); + return *this; + } + + + + + + + + self_type& operator=(const substring_type& aStr) + { + Assign(aStr); + return *this; + } + self_type& operator=(const substring_tuple_type& aTuple) + { + Assign(aTuple); + return *this; + } +# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + const char_type* get() const + + { + return mData; + } +# 128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + char_type CharAt(index_type aIndex) const + { + do { } while(0); + return mData[aIndex]; + } + + char_type operator[](index_type aIndex) const + { + return CharAt(aIndex); + } +# 154 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + int32_t Find(const nsCString& aString, bool aIgnoreCase = false, + int32_t aOffset = 0, int32_t aCount = -1) const; + int32_t Find(const char* aString, bool aIgnoreCase = false, + int32_t aOffset = 0, int32_t aCount = -1) const; +# 186 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + int32_t RFind(const nsCString& aString, bool aIgnoreCase = false, + int32_t aOffset = -1, int32_t aCount = -1) const; + int32_t RFind(const char* aCString, bool aIgnoreCase = false, + int32_t aOffset = -1, int32_t aCount = -1) const; +# 210 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + int32_t RFindChar(char16_t aChar, int32_t aOffset = -1, + int32_t aCount = -1) const; +# 224 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + int32_t FindCharInSet(const char* aString, int32_t aOffset = 0) const; + int32_t FindCharInSet(const self_type& aString, int32_t aOffset = 0) const + { + return FindCharInSet(aString.get(), aOffset); + } +# 245 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + int32_t RFindCharInSet(const char_type* aString, int32_t aOffset = -1) const; + int32_t RFindCharInSet(const self_type& aString, int32_t aOffset = -1) const + { + return RFindCharInSet(aString.get(), aOffset); + } +# 262 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + int32_t Compare(const char* aString, bool aIgnoreCase = false, + int32_t aCount = -1) const; +# 276 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + bool EqualsIgnoreCase(const char* aString, int32_t aCount = -1) const + { + return Compare(aString, true, aCount) == 0; + } +# 292 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + double ToDouble(nsresult* aErrorCode) const; + + + + + + + + float ToFloat(nsresult* aErrorCode) const + { + return (float)ToDouble(aErrorCode); + } +# 312 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + int32_t ToInteger(nsresult* aErrorCode, uint32_t aRadix = (10)) const; + + + + + + + + int64_t ToInteger64(nsresult* aErrorCode, uint32_t aRadix = (10)) const; +# 340 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + size_type Mid(self_type& aResult, uint32_t aStartPos, uint32_t aCount) const; + + size_type Left(self_type& aResult, size_type aCount) const + { + return Mid(aResult, 0, aCount); + } + + size_type Right(self_type& aResult, size_type aCount) const + { + aCount = XPCOM_MIN(mLength, aCount); + return Mid(aResult, mLength - aCount, aCount); + } +# 362 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + bool SetCharAt(char16_t aChar, uint32_t aIndex); +# 374 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + void StripChars(const char* aSet); + bool StripChars(const char* aSet, const fallible_t&); + + + + + + void StripWhitespace(); + bool StripWhitespace(const fallible_t&); + + + + + + + void ReplaceChar(char_type aOldChar, char_type aNewChar); + void ReplaceChar(const char* aSet, char_type aNewChar); +# 399 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + void ReplaceSubstring(const self_type& aTarget, const self_type& aNewValue); + void ReplaceSubstring(const char_type* aTarget, const char_type* aNewValue); + __attribute__ ((warn_unused_result)) bool ReplaceSubstring(const self_type& aTarget, + const self_type& aNewValue, + const fallible_t&); + __attribute__ ((warn_unused_result)) bool ReplaceSubstring(const char_type* aTarget, + const char_type* aNewValue, + const fallible_t&); +# 419 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + void Trim(const char* aSet, bool aEliminateLeading = true, + bool aEliminateTrailing = true, bool aIgnoreQuotes = false); +# 430 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + void CompressWhitespace(bool aEliminateLeading = true, + bool aEliminateTrailing = true); + + + + + + + void AssignWithConversion(const nsAString& aString); + void AssignWithConversion(const incompatible_char_type* aData, + int32_t aLength = -1); +# 449 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + void Rebind(const char_type* aData, size_type aLength); + + + + + void AssertValidDependentString() + { + do { } while(0); + do { } while(0); + do { } while(0); + + + } + + +protected: + + + nsCString(char_type* aData, size_type aLength, uint32_t aFlags) + : substring_type(aData, aLength, aFlags) + { + } + + struct Segment { + uint32_t mBegin, mLength; + Segment(uint32_t aBegin, uint32_t aLength) + : mBegin(aBegin) + , mLength(aLength) + {} + }; +}; + + +class nsFixedCString : public nsCString +{ +public: + + typedef nsFixedCString self_type; + typedef nsFixedCString fixed_string_type; + +public: +# 501 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + nsFixedCString(char_type* aData, size_type aStorageSize) + : string_type(aData, uint32_t(char_traits::length(aData)), + F_TERMINATED | F_FIXED | F_CLASS_FIXED) + , mFixedCapacity(aStorageSize - 1) + , mFixedBuf(aData) + { + } + + nsFixedCString(char_type* aData, size_type aStorageSize, + size_type aLength) + : string_type(aData, aLength, F_TERMINATED | F_FIXED | F_CLASS_FIXED) + , mFixedCapacity(aStorageSize - 1) + , mFixedBuf(aData) + { + + mFixedBuf[aLength] = char_type(0); + } + + + self_type& operator=(char_type aChar) + { + Assign(aChar); + return *this; + } + self_type& operator=(const char_type* aData) + { + Assign(aData); + return *this; + } + self_type& operator=(const substring_type& aStr) + { + Assign(aStr); + return *this; + } + self_type& operator=(const substring_tuple_type& aTuple) + { + Assign(aTuple); + return *this; + } + +protected: + + friend class nsACString; + + size_type mFixedCapacity; + char_type* mFixedBuf; +}; +# 562 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" +class nsAutoCString : public nsFixedCString +{ +public: + + typedef nsAutoCString self_type; + +public: + + + + + + nsAutoCString() + : fixed_string_type(mStorage, kDefaultStorageSize, 0) + { + } + + explicit + nsAutoCString(char_type aChar) + : fixed_string_type(mStorage, kDefaultStorageSize, 0) + { + Assign(aChar); + } + + explicit + nsAutoCString(const char_type* aData, size_type aLength = size_type(-1)) + : fixed_string_type(mStorage, kDefaultStorageSize, 0) + { + Assign(aData, aLength); + } +# 601 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" + nsAutoCString(const self_type& aStr) + : fixed_string_type(mStorage, kDefaultStorageSize, 0) + { + Assign(aStr); + } + + explicit + nsAutoCString(const substring_type& aStr) + : fixed_string_type(mStorage, kDefaultStorageSize, 0) + { + Assign(aStr); + } + + nsAutoCString(const substring_tuple_type& aTuple) + : fixed_string_type(mStorage, kDefaultStorageSize, 0) + { + Assign(aTuple); + } + + + self_type& operator=(char_type aChar) + { + Assign(aChar); + return *this; + } + self_type& operator=(const char_type* aData) + { + Assign(aData); + return *this; + } + + + + + + + + self_type& operator=(const self_type& aStr) + { + Assign(aStr); + return *this; + } + self_type& operator=(const substring_type& aStr) + { + Assign(aStr); + return *this; + } + self_type& operator=(const substring_tuple_type& aTuple) + { + Assign(aTuple); + return *this; + } + + enum + { + kDefaultStorageSize = 64 + }; + +private: + + char_type mStorage[kDefaultStorageSize]; +}; + + + + + + + +template class nsTArrayElementTraits; +template<> +class nsTArrayElementTraits +{ +public: + template struct Dont_Instantiate_nsTArray_of; + template struct Instead_Use_nsTArray_of; + + static Dont_Instantiate_nsTArray_of* + Construct(Instead_Use_nsTArray_of* aE) + { + return 0; + } + template + static Dont_Instantiate_nsTArray_of* + Construct(Instead_Use_nsTArray_of* aE, const A& aArg) + { + return 0; + } + static Dont_Instantiate_nsTArray_of* + Destruct(Instead_Use_nsTArray_of* aE) + { + return 0; + } +}; +# 708 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" +class nsXPIDLCString : public nsCString +{ +public: + + typedef nsXPIDLCString self_type; + +public: + + nsXPIDLCString() + : string_type(char_traits::sEmptyBuffer, 0, F_TERMINATED | F_VOIDED) + { + } + + + nsXPIDLCString(const self_type& aStr) + : string_type(char_traits::sEmptyBuffer, 0, F_TERMINATED | F_VOIDED) + { + Assign(aStr); + } + + + + + + const char_type* get() const + + { + return (mFlags & F_VOIDED) ? nullptr : mData; + } + + + + operator const char_type*() const + { + return get(); + } + + + char_type operator[](int32_t aIndex) const + { + return CharAt(index_type(aIndex)); + } + + + self_type& operator=(char_type aChar) + { + Assign(aChar); + return *this; + } + self_type& operator=(const char_type* aStr) + { + Assign(aStr); + return *this; + } + self_type& operator=(const self_type& aStr) + { + Assign(aStr); + return *this; + } + self_type& operator=(const substring_type& aStr) + { + Assign(aStr); + return *this; + } + self_type& operator=(const substring_tuple_type& aTuple) + { + Assign(aTuple); + return *this; + } +}; +# 792 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" +class nsCGetterCopies +{ +public: + typedef char char_type; + + explicit nsCGetterCopies(nsACString& aStr) + : mString(aStr) + , mData(nullptr) + { + } + + ~nsCGetterCopies() + { + mString.Adopt(mData); + } + + operator char_type**() + { + return &mData; + } + +private: + nsACString& mString; + char_type* mData; +}; + +inline nsCGetterCopies +getter_Copies(nsACString& aString) +{ + return nsCGetterCopies(aString); +} +# 833 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" +class nsAdoptingCString : public nsXPIDLCString +{ +public: + + typedef nsAdoptingCString self_type; + +public: + + explicit nsAdoptingCString() + { + } + explicit nsAdoptingCString(char_type* aStr, + size_type aLength = size_type(-1)) + { + Adopt(aStr, aLength); + } + + + + + + nsAdoptingCString(const self_type& aStr) + : nsXPIDLCString() + { + *this = aStr; + } + + + self_type& operator=(const substring_type& aStr) + { + Assign(aStr); + return *this; + } + self_type& operator=(const substring_tuple_type& aTuple) + { + Assign(aTuple); + return *this; + } + + + + + self_type& operator=(const self_type& aStr); + +private: + self_type& operator=(const char_type* aData) = delete; + self_type& operator=(char_type* aData) = delete; +}; +# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1 +# 40 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2 + +static_assert(sizeof(char16_t) == 2, "size of char16_t must be 2"); +static_assert(sizeof(nsString::char_type) == 2, + "size of nsString::char_type must be 2"); +static_assert(nsString::char_type(-1) > nsString::char_type(0), + "nsString::char_type must be unsigned"); +static_assert(sizeof(nsCString::char_type) == 1, + "size of nsCString::char_type must be 1"); + + + + + +class NS_LossyConvertUTF16toASCII : public nsAutoCString +{ +public: + explicit NS_LossyConvertUTF16toASCII(const char16ptr_t aString) + { + LossyAppendUTF16toASCII(aString, *this); + } + + NS_LossyConvertUTF16toASCII(const char16ptr_t aString, uint32_t aLength) + { + LossyAppendUTF16toASCII(Substring(aString, aLength), *this); + } + + explicit NS_LossyConvertUTF16toASCII(const nsAString& aString) + { + LossyAppendUTF16toASCII(aString, *this); + } + +private: + + NS_LossyConvertUTF16toASCII(char) = delete; +}; + + +class NS_ConvertASCIItoUTF16 : public nsAutoString +{ +public: + explicit NS_ConvertASCIItoUTF16(const char* aCString) + { + AppendASCIItoUTF16(aCString, *this); + } + + NS_ConvertASCIItoUTF16(const char* aCString, uint32_t aLength) + { + AppendASCIItoUTF16(Substring(aCString, aLength), *this); + } + + explicit NS_ConvertASCIItoUTF16(const nsACString& aCString) + { + AppendASCIItoUTF16(aCString, *this); + } + +private: + + NS_ConvertASCIItoUTF16(char16_t) = delete; +}; + + + + + +class NS_ConvertUTF16toUTF8 : public nsAutoCString +{ +public: + explicit NS_ConvertUTF16toUTF8(const char16ptr_t aString) + { + AppendUTF16toUTF8(aString, *this); + } + + NS_ConvertUTF16toUTF8(const char16ptr_t aString, uint32_t aLength) + { + AppendUTF16toUTF8(Substring(aString, aLength), *this); + } + + explicit NS_ConvertUTF16toUTF8(const nsAString& aString) + { + AppendUTF16toUTF8(aString, *this); + } + +private: + + NS_ConvertUTF16toUTF8(char) = delete; +}; + + +class NS_ConvertUTF8toUTF16 : public nsAutoString +{ +public: + explicit NS_ConvertUTF8toUTF16(const char* aCString) + { + AppendUTF8toUTF16(aCString, *this); + } + + NS_ConvertUTF8toUTF16(const char* aCString, uint32_t aLength) + { + AppendUTF8toUTF16(Substring(aCString, aLength), *this); + } + + explicit NS_ConvertUTF8toUTF16(const nsACString& aCString) + { + AppendUTF8toUTF16(aCString, *this); + } + +private: + + NS_ConvertUTF8toUTF16(char16_t) = delete; +}; +# 180 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" +inline char16_t* +wwc(char16_t* aStr) +{ + return aStr; +} + +inline const char16_t* +wwc(const char16_t* aStr) +{ + return aStr; +} + + + + +typedef nsAutoString nsVoidableString; + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 1 +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2 + + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1 +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h" 1 +# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h" +class nsDependentString : public nsString +{ +public: + + typedef nsDependentString self_type; + +public: + + + + + + nsDependentString(const char_type* aStart, const char_type* aEnd); + + nsDependentString(const char_type* aData, uint32_t aLength) + : string_type(const_cast(aData), aLength, F_TERMINATED) + { + AssertValidDependentString(); + } +# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h" + explicit + nsDependentString(const char_type* aData) + : string_type(const_cast(aData), + uint32_t(char_traits::length(aData)), F_TERMINATED) + { + AssertValidDependentString(); + } +# 62 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h" + nsDependentString(const string_type& aStr, uint32_t aStartPos) + : string_type() + { + Rebind(aStr, aStartPos); + } + + + nsDependentString() + : string_type() + { + } +# 84 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h" + using nsString::Rebind; + void Rebind(const char_type* aData) + { + Rebind(aData, uint32_t(char_traits::length(aData))); + } + + void Rebind(const char_type* aStart, const char_type* aEnd); + void Rebind(const string_type&, uint32_t aStartPos); + +private: + + + nsDependentString(const substring_tuple_type&) = delete; +}; +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1 +# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2 + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1 +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h" 1 +# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h" +class nsDependentCString : public nsCString +{ +public: + + typedef nsDependentCString self_type; + +public: + + + + + + nsDependentCString(const char_type* aStart, const char_type* aEnd); + + nsDependentCString(const char_type* aData, uint32_t aLength) + : string_type(const_cast(aData), aLength, F_TERMINATED) + { + AssertValidDependentString(); + } +# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h" + explicit + nsDependentCString(const char_type* aData) + : string_type(const_cast(aData), + uint32_t(char_traits::length(aData)), F_TERMINATED) + { + AssertValidDependentString(); + } +# 62 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h" + nsDependentCString(const string_type& aStr, uint32_t aStartPos) + : string_type() + { + Rebind(aStr, aStartPos); + } + + + nsDependentCString() + : string_type() + { + } +# 84 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h" + using nsCString::Rebind; + void Rebind(const char_type* aData) + { + Rebind(aData, uint32_t(char_traits::length(aData))); + } + + void Rebind(const char_type* aStart, const char_type* aEnd); + void Rebind(const string_type&, uint32_t aStartPos); + +private: + + + nsDependentCString(const substring_tuple_type&) = delete; +}; +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1 +# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2 +# 198 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 1 +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 1 +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2 + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1 +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTLiteralString.h" 1 +# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTLiteralString.h" +class nsLiteralString : public mozilla::detail::nsStringRepr +{ +public: + + typedef nsLiteralString self_type; + +public: + + + + + + template + explicit nsLiteralString(const char_type (&aStr)[N]) + : base_string_type(const_cast(aStr), N - 1, F_TERMINATED | F_LITERAL) + { + } + + + + + + + const nsString& AsString() const + { + return *reinterpret_cast(this); + } + + operator const nsString&() const + { + return AsString(); + } +# 59 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTLiteralString.h" + const char_type* get() const && = delete; + const char_type* get() const & + + { + return mData; + } + +private: + + + template + nsLiteralString(char_type (&aStr)[N]) = delete; + + self_type& operator=(const self_type&) = delete; +}; + +static_assert(sizeof(nsLiteralString) == sizeof(nsString), + "nsTLiteralString_CharT can masquerade as nsTString_CharT, " + "so they must have identical layout"); +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1 +# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2 + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1 +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTLiteralString.h" 1 +# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTLiteralString.h" +class nsLiteralCString : public mozilla::detail::nsCStringRepr +{ +public: + + typedef nsLiteralCString self_type; + +public: + + + + + + template + explicit nsLiteralCString(const char_type (&aStr)[N]) + : base_string_type(const_cast(aStr), N - 1, F_TERMINATED | F_LITERAL) + { + } + + + + + + + const nsCString& AsString() const + { + return *reinterpret_cast(this); + } + + operator const nsCString&() const + { + return AsString(); + } +# 59 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTLiteralString.h" + const char_type* get() const && = delete; + const char_type* get() const & + + { + return mData; + } + +private: + + + template + nsLiteralCString(char_type (&aStr)[N]) = delete; + + self_type& operator=(const self_type&) = delete; +}; + +static_assert(sizeof(nsLiteralCString) == sizeof(nsCString), + "nsTLiteralString_CharT can masquerade as nsTString_CharT, " + "so they must have identical layout"); +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1 +# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2 +# 199 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 1 +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2 + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1 +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTPromiseFlatString.h" 1 +# 67 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTPromiseFlatString.h" +class nsPromiseFlatString : public nsString +{ +public: + + typedef nsPromiseFlatString self_type; + +private: + + void Init(const substring_type&); + + + void operator=(const self_type&) = delete; + + + nsPromiseFlatString() = delete; + + + nsPromiseFlatString(const string_type& aStr) = delete; + +public: + + explicit + nsPromiseFlatString(const substring_type& aStr) + : string_type() + { + Init(aStr); + } + + explicit + nsPromiseFlatString(const substring_tuple_type& aTuple) + : string_type() + { + + + Assign(aTuple); + } +}; + + + +template +const nsPromiseFlatString +PromiseFlatString(const T& aString) +{ + return nsPromiseFlatString(aString); +} +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1 +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2 + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1 +# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTPromiseFlatString.h" 1 +# 67 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTPromiseFlatString.h" +class nsPromiseFlatCString : public nsCString +{ +public: + + typedef nsPromiseFlatCString self_type; + +private: + + void Init(const substring_type&); + + + void operator=(const self_type&) = delete; + + + nsPromiseFlatCString() = delete; + + + nsPromiseFlatCString(const string_type& aStr) = delete; + +public: + + explicit + nsPromiseFlatCString(const substring_type& aStr) + : string_type() + { + Init(aStr); + } + + explicit + nsPromiseFlatCString(const substring_tuple_type& aTuple) + : string_type() + { + + + Assign(aTuple); + } +}; + + + +template +const nsPromiseFlatCString +PromiseFlatCString(const T& aString) +{ + return nsPromiseFlatCString(aString); +} +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1 +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2 +# 200 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2 + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMemory.h" 1 +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMemory.h" +class nsIMemory; +# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMemory.h" +class nsMemory +{ +public: + static nsresult HeapMinimize(bool aImmediate); + static void* Clone(const void* aPtr, size_t aSize); + static nsIMemory* GetGlobalMemoryService(); +}; +# 113 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMemory.h" +namespace mozilla { +template +struct AlignmentTestStruct +{ + char c; + T t; +}; +} + + + + + + + +enum nsAssignmentType +{ + NS_ASSIGNMENT_COPY, + NS_ASSIGNMENT_DEPEND, + NS_ASSIGNMENT_ADOPT +}; +# 203 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2 + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plhash.h" 1 +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plhash.h" +extern "C" { + +typedef struct PLHashEntry PLHashEntry; +typedef struct PLHashTable PLHashTable; +typedef PRUint32 PLHashNumber; + +typedef PLHashNumber ( *PLHashFunction)(const void *key); +typedef PRIntn ( *PLHashComparator)(const void *v1, const void *v2); + +typedef PRIntn ( *PLHashEnumerator)(PLHashEntry *he, PRIntn i, void *arg); + + + + + + + +typedef struct PLHashAllocOps { + void * ( *allocTable)(void *pool, PRSize size); + void ( *freeTable)(void *pool, void *item); + PLHashEntry * ( *allocEntry)(void *pool, const void *key); + void ( *freeEntry)(void *pool, PLHashEntry *he, PRUintn flag); +} PLHashAllocOps; + + + + +struct PLHashEntry { + PLHashEntry *next; + PLHashNumber keyHash; + const void *key; + void *value; +}; + +struct PLHashTable { + PLHashEntry **buckets; + PRUint32 nentries; + PRUint32 shift; + PLHashFunction keyHash; + PLHashComparator keyCompare; + PLHashComparator valueCompare; + const PLHashAllocOps *allocOps; + void *allocPriv; + + + + + + +}; + + + + + +extern __attribute__((visibility("default"))) PLHashTable * +PL_NewHashTable(PRUint32 numBuckets, PLHashFunction keyHash, + PLHashComparator keyCompare, PLHashComparator valueCompare, + const PLHashAllocOps *allocOps, void *allocPriv); + +extern __attribute__((visibility("default"))) void +PL_HashTableDestroy(PLHashTable *ht); + + +extern __attribute__((visibility("default"))) PLHashEntry * +PL_HashTableAdd(PLHashTable *ht, const void *key, void *value); + +extern __attribute__((visibility("default"))) PRBool +PL_HashTableRemove(PLHashTable *ht, const void *key); + +extern __attribute__((visibility("default"))) void * +PL_HashTableLookup(PLHashTable *ht, const void *key); + +extern __attribute__((visibility("default"))) void * +PL_HashTableLookupConst(PLHashTable *ht, const void *key); + +extern __attribute__((visibility("default"))) PRIntn +PL_HashTableEnumerateEntries(PLHashTable *ht, PLHashEnumerator f, void *arg); + + +extern __attribute__((visibility("default"))) PLHashNumber +PL_HashString(const void *key); + + +extern __attribute__((visibility("default"))) PRIntn +PL_CompareStrings(const void *v1, const void *v2); + + +extern __attribute__((visibility("default"))) PRIntn +PL_CompareValues(const void *v1, const void *v2); + + +extern __attribute__((visibility("default"))) PLHashEntry ** +PL_HashTableRawLookup(PLHashTable *ht, PLHashNumber keyHash, const void *key); + +extern __attribute__((visibility("default"))) PLHashEntry ** +PL_HashTableRawLookupConst(PLHashTable *ht, PLHashNumber keyHash, + const void *key); + +extern __attribute__((visibility("default"))) PLHashEntry * +PL_HashTableRawAdd(PLHashTable *ht, PLHashEntry **hep, PLHashNumber keyHash, + const void *key, void *value); + +extern __attribute__((visibility("default"))) void +PL_HashTableRawRemove(PLHashTable *ht, PLHashEntry **hep, PLHashEntry *he); + + +extern __attribute__((visibility("default"))) PRIntn +PL_HashTableDump(PLHashTable *ht, PLHashEnumerator dump, FILE *fp); + +} +# 206 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2 +# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringGlue.h" 2 +# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h" 2 + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAtom.h" 1 +# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAtom.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h" 1 +# 111 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h" +namespace mozilla { +template class OwningNonNull; +} + +template +inline already_AddRefed +dont_AddRef(T* aRawPtr) +{ + return already_AddRefed(aRawPtr); +} + +template +inline already_AddRefed&& +dont_AddRef(already_AddRefed&& aAlreadyAddRefedPtr) +{ + return mozilla::Move(aAlreadyAddRefedPtr); +} +# 146 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h" +class nsCOMPtr_helper +{ +public: + virtual nsresult operator()(const nsIID&, void**) const = 0; +}; + + + + + + + +class nsQueryInterface final +{ +public: + explicit + nsQueryInterface(nsISupports* aRawPtr) : mRawPtr(aRawPtr) {} + + nsresult operator()(const nsIID& aIID, void**) const; + +private: + nsISupports* mRawPtr; +}; + +class nsQueryInterfaceWithError final +{ +public: + nsQueryInterfaceWithError(nsISupports* aRawPtr, nsresult* aError) + : mRawPtr(aRawPtr) + , mErrorPtr(aError) + { + } + + nsresult operator()(const nsIID& aIID, void**) const; + +private: + nsISupports* mRawPtr; + nsresult* mErrorPtr; +}; + +inline nsQueryInterface +do_QueryInterface(nsISupports* aRawPtr) +{ + return nsQueryInterface(aRawPtr); +} + +inline nsQueryInterfaceWithError +do_QueryInterface(nsISupports* aRawPtr, nsresult* aError) +{ + return nsQueryInterfaceWithError(aRawPtr, aError); +} + +template +inline void +do_QueryInterface(already_AddRefed&) +{ + + + +} + +template +inline void +do_QueryInterface(already_AddRefed&, nsresult*) +{ + + + +} + + + + +class nsGetServiceByCID final +{ +public: + explicit nsGetServiceByCID(const nsCID& aCID) : mCID(aCID) {} + + nsresult operator()(const nsIID&, void**) const; + +private: + const nsCID& mCID; +}; + +class nsGetServiceByCIDWithError final +{ +public: + nsGetServiceByCIDWithError(const nsCID& aCID, nsresult* aErrorPtr) + : mCID(aCID) + , mErrorPtr(aErrorPtr) + { + } + + nsresult operator()(const nsIID&, void**) const; + +private: + const nsCID& mCID; + nsresult* mErrorPtr; +}; + +class nsGetServiceByContractID final +{ +public: + explicit nsGetServiceByContractID(const char* aContractID) + : mContractID(aContractID) + { + } + + nsresult operator()(const nsIID&, void**) const; + +private: + const char* mContractID; +}; + +class nsGetServiceByContractIDWithError final +{ +public: + nsGetServiceByContractIDWithError(const char* aContractID, nsresult* aErrorPtr) + : mContractID(aContractID) + , mErrorPtr(aErrorPtr) + { + } + + nsresult operator()(const nsIID&, void**) const; + +private: + const char* mContractID; + nsresult* mErrorPtr; +}; +# 285 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h" +class nsCOMPtr_base +{ +public: + explicit nsCOMPtr_base(nsISupports* aRawPtr = nullptr) : mRawPtr(aRawPtr) {} + + ~nsCOMPtr_base() + { + ; + if (mRawPtr) { + (mRawPtr)->Release(); + } + } + + void + assign_with_AddRef(nsISupports*); + void + assign_from_qi(const nsQueryInterface, const nsIID&); + void + assign_from_qi_with_error(const nsQueryInterfaceWithError&, const nsIID&); + void + assign_from_gs_cid(const nsGetServiceByCID, const nsIID&); + void + assign_from_gs_cid_with_error(const nsGetServiceByCIDWithError&, const nsIID&); + void + assign_from_gs_contractid(const nsGetServiceByContractID, const nsIID&); + void + assign_from_gs_contractid_with_error(const nsGetServiceByContractIDWithError&, + const nsIID&); + void + assign_from_helper(const nsCOMPtr_helper&, const nsIID&); + void** + begin_assignment(); + +protected: + nsISupports* __attribute__((__may_alias__)) mRawPtr; + + void assign_assuming_AddRef(nsISupports* aNewPtr) + { + + + + + + + nsISupports* oldPtr = mRawPtr; + mRawPtr = aNewPtr; + ; + ; + if (oldPtr) { + (oldPtr)->Release(); + } + } +}; + + + + +template +char (&TestForIID(decltype(&(T::template COMTypeInfo::kIID))))[2]; +template +char TestForIID(...); + +template +class nsCOMPtr final + + : private nsCOMPtr_base + +{ +# 387 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h" + void assert_validity() + { + static_assert(1 < sizeof(TestForIID(nullptr)), "nsCOMPtr only works " + "for types with IIDs. Either use RefPtr; add an IID to " + "your type with NS_DECLARE_STATIC_IID_ACCESSOR/" + "NS_DEFINE_STATIC_IID_ACCESSOR; or make the nsCOMPtr point " + "to a base class with an IID."); + } + +public: + typedef T element_type; +# 426 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h" + nsCOMPtr() + : nsCOMPtr_base(nullptr) + { + assert_validity(); + ; + } + + nsCOMPtr(decltype(nullptr)) + : nsCOMPtr_base(nullptr) + { + assert_validity(); + ; + } + + nsCOMPtr(const nsCOMPtr& aSmartPtr) + : nsCOMPtr_base(aSmartPtr.mRawPtr) + { + assert_validity(); + if (mRawPtr) { + (mRawPtr)->AddRef(); + } + ; + } + + nsCOMPtr(nsCOMPtr&& aSmartPtr) + : nsCOMPtr_base(aSmartPtr.mRawPtr) + { + assert_validity(); + aSmartPtr.mRawPtr = nullptr; + ; + ; + } + + nsCOMPtr(T* aRawPtr) + : nsCOMPtr_base(aRawPtr) + { + assert_validity(); + if (mRawPtr) { + (mRawPtr)->AddRef(); + } + ; + ; + } + + nsCOMPtr(already_AddRefed& aSmartPtr) + : nsCOMPtr_base(aSmartPtr.take()) + { + assert_validity(); + ; + ; + } + + + nsCOMPtr(already_AddRefed&& aSmartPtr) + : nsCOMPtr_base(aSmartPtr.take()) + { + assert_validity(); + ; + ; + } + + + template + nsCOMPtr(already_AddRefed& aSmartPtr) + : nsCOMPtr_base(static_cast(aSmartPtr.take())) + { + assert_validity(); + + static_assert(mozilla::IsBaseOf::value, + "U is not a subclass of T"); + ; + ; + } + + + template + nsCOMPtr(already_AddRefed&& aSmartPtr) + : nsCOMPtr_base(static_cast(aSmartPtr.take())) + { + assert_validity(); + + static_assert(mozilla::IsBaseOf::value, + "U is not a subclass of T"); + ; + ; + } + + + nsCOMPtr(const nsQueryInterface aQI) + : nsCOMPtr_base(nullptr) + { + assert_validity(); + ; + assign_from_qi(aQI, (T::template COMTypeInfo::kIID)); + } + + + nsCOMPtr(const nsQueryInterfaceWithError& aQI) + : nsCOMPtr_base(nullptr) + { + assert_validity(); + ; + assign_from_qi_with_error(aQI, (T::template COMTypeInfo::kIID)); + } + + + nsCOMPtr(const nsGetServiceByCID aGS) + : nsCOMPtr_base(nullptr) + { + assert_validity(); + ; + assign_from_gs_cid(aGS, (T::template COMTypeInfo::kIID)); + } + + + nsCOMPtr(const nsGetServiceByCIDWithError& aGS) + : nsCOMPtr_base(nullptr) + { + assert_validity(); + ; + assign_from_gs_cid_with_error(aGS, (T::template COMTypeInfo::kIID)); + } + + + nsCOMPtr(const nsGetServiceByContractID aGS) + : nsCOMPtr_base(nullptr) + { + assert_validity(); + ; + assign_from_gs_contractid(aGS, (T::template COMTypeInfo::kIID)); + } + + + nsCOMPtr(const nsGetServiceByContractIDWithError& aGS) + : nsCOMPtr_base(nullptr) + { + assert_validity(); + ; + assign_from_gs_contractid_with_error(aGS, (T::template COMTypeInfo::kIID)); + } + + + + nsCOMPtr(const nsCOMPtr_helper& aHelper) + : nsCOMPtr_base(nullptr) + { + assert_validity(); + ; + assign_from_helper(aHelper, (T::template COMTypeInfo::kIID)); + ; + } + + + template + nsCOMPtr(const mozilla::OwningNonNull& aOther); + + + + + nsCOMPtr& operator=(const nsCOMPtr& aRhs) + { + assign_with_AddRef(aRhs.mRawPtr); + return *this; + } + + nsCOMPtr& operator=(T* aRhs) + { + assign_with_AddRef(aRhs); + ; + return *this; + } + + nsCOMPtr& operator=(decltype(nullptr)) + { + assign_assuming_AddRef(nullptr); + return *this; + } + + + template + nsCOMPtr& operator=(already_AddRefed& aRhs) + { + + static_assert(mozilla::IsBaseOf::value, + "U is not a subclass of T"); + assign_assuming_AddRef(static_cast(aRhs.take())); + ; + return *this; + } + + + template + nsCOMPtr& operator=(already_AddRefed&& aRhs) + { + + static_assert(mozilla::IsBaseOf::value, + "U is not a subclass of T"); + assign_assuming_AddRef(static_cast(aRhs.take())); + ; + return *this; + } + + + nsCOMPtr& operator=(const nsQueryInterface aRhs) + { + assign_from_qi(aRhs, (T::template COMTypeInfo::kIID)); + return *this; + } + + + nsCOMPtr& operator=(const nsQueryInterfaceWithError& aRhs) + { + assign_from_qi_with_error(aRhs, (T::template COMTypeInfo::kIID)); + return *this; + } + + + nsCOMPtr& operator=(const nsGetServiceByCID aRhs) + { + assign_from_gs_cid(aRhs, (T::template COMTypeInfo::kIID)); + return *this; + } + + + nsCOMPtr& operator=(const nsGetServiceByCIDWithError& aRhs) + { + assign_from_gs_cid_with_error(aRhs, (T::template COMTypeInfo::kIID)); + return *this; + } + + + nsCOMPtr& operator=(const nsGetServiceByContractID aRhs) + { + assign_from_gs_contractid(aRhs, (T::template COMTypeInfo::kIID)); + return *this; + } + + + nsCOMPtr& operator=(const nsGetServiceByContractIDWithError& aRhs) + { + assign_from_gs_contractid_with_error(aRhs, (T::template COMTypeInfo::kIID)); + return *this; + } + + + + nsCOMPtr& operator=(const nsCOMPtr_helper& aRhs) + { + assign_from_helper(aRhs, (T::template COMTypeInfo::kIID)); + ; + return *this; + } + + + template + nsCOMPtr& operator=(const mozilla::OwningNonNull& aOther); + + + void swap(nsCOMPtr& aRhs) + { + + nsISupports* temp = aRhs.mRawPtr; + + + + ; + ; + ; + ; + aRhs.mRawPtr = mRawPtr; + mRawPtr = temp; + + } + + + void swap(T*& aRhs) + { + + nsISupports* temp = aRhs; + + + + ; + ; + aRhs = reinterpret_cast(mRawPtr); + mRawPtr = temp; + ; + } + + + + + + + already_AddRefed forget() + { + T* temp = nullptr; + swap(temp); + return already_AddRefed(temp); + } + + + + + template + void forget(I** aRhs) + { + do { } while(0); + ; + *aRhs = get(); + mRawPtr = nullptr; + } + + + + + T* get() const { return reinterpret_cast(mRawPtr); } + + + + + + + + operator T*() const & { return get(); } + + + + + operator T*() const && = delete; + + + explicit operator bool() const { return !!mRawPtr; } + + T* operator->() const + { + do { } while (0); + + return get(); + } + + + nsCOMPtr* get_address() { return this; } + const nsCOMPtr* get_address() const { return this; } + +public: + T& operator*() const + { + do { } while (0); + + return *get(); + } + + T** StartAssignment() + { + + return reinterpret_cast(begin_assignment()); + + + + + } +}; +# 800 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h" +template<> +class nsCOMPtr + : private nsCOMPtr_base +{ +public: + typedef nsISupports element_type; + + + + nsCOMPtr() + : nsCOMPtr_base(nullptr) + { + ; + } + + nsCOMPtr(decltype(nullptr)) + : nsCOMPtr_base(nullptr) + { + ; + } + + nsCOMPtr(const nsCOMPtr& aSmartPtr) + : nsCOMPtr_base(aSmartPtr.mRawPtr) + { + if (mRawPtr) { + (mRawPtr)->AddRef(); + } + ; + } + + nsCOMPtr(nsISupports* aRawPtr) + : nsCOMPtr_base(aRawPtr) + { + if (mRawPtr) { + (mRawPtr)->AddRef(); + } + ; + } + + + nsCOMPtr(already_AddRefed& aSmartPtr) + : nsCOMPtr_base(aSmartPtr.take()) + { + ; + } + + + nsCOMPtr(already_AddRefed&& aSmartPtr) + : nsCOMPtr_base(aSmartPtr.take()) + { + ; + } + + + nsCOMPtr(const nsQueryInterface aQI) + : nsCOMPtr_base(nullptr) + { + ; + assign_from_qi(aQI, (nsISupports::COMTypeInfo::kIID)); + } + + + nsCOMPtr(const nsQueryInterfaceWithError& aQI) + : nsCOMPtr_base(nullptr) + { + ; + assign_from_qi_with_error(aQI, (nsISupports::COMTypeInfo::kIID)); + } + + + nsCOMPtr(const nsGetServiceByCID aGS) + : nsCOMPtr_base(nullptr) + { + ; + assign_from_gs_cid(aGS, (nsISupports::COMTypeInfo::kIID)); + } + + + nsCOMPtr(const nsGetServiceByCIDWithError& aGS) + : nsCOMPtr_base(nullptr) + { + ; + assign_from_gs_cid_with_error(aGS, (nsISupports::COMTypeInfo::kIID)); + } + + + nsCOMPtr(const nsGetServiceByContractID aGS) + : nsCOMPtr_base(nullptr) + { + ; + assign_from_gs_contractid(aGS, (nsISupports::COMTypeInfo::kIID)); + } + + + nsCOMPtr(const nsGetServiceByContractIDWithError& aGS) + : nsCOMPtr_base(nullptr) + { + ; + assign_from_gs_contractid_with_error(aGS, (nsISupports::COMTypeInfo::kIID)); + } + + + + nsCOMPtr(const nsCOMPtr_helper& aHelper) + : nsCOMPtr_base(nullptr) + { + ; + assign_from_helper(aHelper, (nsISupports::COMTypeInfo::kIID)); + } + + + + + nsCOMPtr& operator=(const nsCOMPtr& aRhs) + { + assign_with_AddRef(aRhs.mRawPtr); + return *this; + } + + nsCOMPtr& operator=(nsISupports* aRhs) + { + assign_with_AddRef(aRhs); + return *this; + } + + nsCOMPtr& operator=(decltype(nullptr)) + { + assign_assuming_AddRef(nullptr); + return *this; + } + + + nsCOMPtr& operator=(already_AddRefed& aRhs) + { + assign_assuming_AddRef(aRhs.take()); + return *this; + } + + + nsCOMPtr& operator=(already_AddRefed&& aRhs) + { + assign_assuming_AddRef(aRhs.take()); + return *this; + } + + + nsCOMPtr& operator=(const nsQueryInterface aRhs) + { + assign_from_qi(aRhs, (nsISupports::COMTypeInfo::kIID)); + return *this; + } + + + nsCOMPtr& operator=(const nsQueryInterfaceWithError& aRhs) + { + assign_from_qi_with_error(aRhs, (nsISupports::COMTypeInfo::kIID)); + return *this; + } + + + nsCOMPtr& operator=(const nsGetServiceByCID aRhs) + { + assign_from_gs_cid(aRhs, (nsISupports::COMTypeInfo::kIID)); + return *this; + } + + + nsCOMPtr& operator=(const nsGetServiceByCIDWithError& aRhs) + { + assign_from_gs_cid_with_error(aRhs, (nsISupports::COMTypeInfo::kIID)); + return *this; + } + + + nsCOMPtr& operator=(const nsGetServiceByContractID aRhs) + { + assign_from_gs_contractid(aRhs, (nsISupports::COMTypeInfo::kIID)); + return *this; + } + + + nsCOMPtr& operator=(const nsGetServiceByContractIDWithError& aRhs) + { + assign_from_gs_contractid_with_error(aRhs, (nsISupports::COMTypeInfo::kIID)); + return *this; + } + + + + nsCOMPtr& operator=(const nsCOMPtr_helper& aRhs) + { + assign_from_helper(aRhs, (nsISupports::COMTypeInfo::kIID)); + return *this; + } + + + void swap(nsCOMPtr& aRhs) + { + nsISupports* temp = aRhs.mRawPtr; + ; + ; + ; + ; + aRhs.mRawPtr = mRawPtr; + mRawPtr = temp; + } + + + void swap(nsISupports*& aRhs) + { + nsISupports* temp = aRhs; + ; + ; + aRhs = mRawPtr; + mRawPtr = temp; + } + + + + already_AddRefed forget() + { + nsISupports* temp = nullptr; + swap(temp); + return already_AddRefed(temp); + } + + + + + void forget(nsISupports** aRhs) + { + do { } while(0); + *aRhs = nullptr; + swap(*aRhs); + } + + + + + + + nsISupports* get() const { return reinterpret_cast(mRawPtr); } + + + + + + + + operator nsISupports* () const { return get(); } + + nsISupports* operator->() const + { + do { } while (0); + + return get(); + } + + + nsCOMPtr* get_address() { return this; } + const nsCOMPtr* get_address() const { return this; } + +public: + + nsISupports& operator*() const + { + do { } while (0); + + return *get(); + } + + nsISupports** StartAssignment() + { + + return reinterpret_cast(begin_assignment()); + + + + + } +}; + +template +inline void +ImplCycleCollectionUnlink(nsCOMPtr& aField) +{ + aField = nullptr; +} + +template +inline void +ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback, + nsCOMPtr& aField, + const char* aName, + uint32_t aFlags = 0) +{ + CycleCollectionNoteChild(aCallback, aField.get(), aName, aFlags); +} +# 1206 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h" +template +inline nsCOMPtr* +address_of(nsCOMPtr& aPtr) +{ + return aPtr.get_address(); +} + +template +inline const nsCOMPtr* +address_of(const nsCOMPtr& aPtr) +{ + return aPtr.get_address(); +} +# 1235 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h" +template +class nsGetterAddRefs +{ +public: + explicit nsGetterAddRefs(nsCOMPtr& aSmartPtr) + : mTargetSmartPtr(aSmartPtr) + { + } +# 1258 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h" + operator void**() + { + return reinterpret_cast(mTargetSmartPtr.StartAssignment()); + } + + operator T**() { return mTargetSmartPtr.StartAssignment(); } + T*& operator*() { return *(mTargetSmartPtr.StartAssignment()); } + +private: + nsCOMPtr& mTargetSmartPtr; +}; + + +template<> +class nsGetterAddRefs +{ +public: + explicit nsGetterAddRefs(nsCOMPtr& aSmartPtr) + : mTargetSmartPtr(aSmartPtr) + { + } +# 1288 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h" + operator void**() + { + return reinterpret_cast(mTargetSmartPtr.StartAssignment()); + } + + operator nsISupports**() { return mTargetSmartPtr.StartAssignment(); } + nsISupports*& operator*() { return *(mTargetSmartPtr.StartAssignment()); } + +private: + nsCOMPtr& mTargetSmartPtr; +}; + +template +inline nsGetterAddRefs +getter_AddRefs(nsCOMPtr& aSmartPtr) +{ + return nsGetterAddRefs(aSmartPtr); +} + +template +inline nsresult +CallQueryInterface(T* aSource, nsGetterAddRefs aDestination) +{ + return CallQueryInterface(aSource, + static_cast(aDestination)); +} + + + + +template +inline bool +operator==(const nsCOMPtr& aLhs, const nsCOMPtr& aRhs) +{ + return static_cast(aLhs.get()) == static_cast(aRhs.get()); +} + + +template +inline bool +operator!=(const nsCOMPtr& aLhs, const nsCOMPtr& aRhs) +{ + return static_cast(aLhs.get()) != static_cast(aRhs.get()); +} + + + + +template +inline bool +operator==(const nsCOMPtr& aLhs, const U* aRhs) +{ + return static_cast(aLhs.get()) == aRhs; +} + +template +inline bool +operator==(const U* aLhs, const nsCOMPtr& aRhs) +{ + return aLhs == static_cast(aRhs.get()); +} + +template +inline bool +operator!=(const nsCOMPtr& aLhs, const U* aRhs) +{ + return static_cast(aLhs.get()) != aRhs; +} + +template +inline bool +operator!=(const U* aLhs, const nsCOMPtr& aRhs) +{ + return aLhs != static_cast(aRhs.get()); +} + +template +inline bool +operator==(const nsCOMPtr& aLhs, U* aRhs) +{ + return static_cast(aLhs.get()) == const_cast(aRhs); +} + +template +inline bool +operator==(U* aLhs, const nsCOMPtr& aRhs) +{ + return const_cast(aLhs) == static_cast(aRhs.get()); +} + +template +inline bool +operator!=(const nsCOMPtr& aLhs, U* aRhs) +{ + return static_cast(aLhs.get()) != const_cast(aRhs); +} + +template +inline bool +operator!=(U* aLhs, const nsCOMPtr& aRhs) +{ + return const_cast(aLhs) != static_cast(aRhs.get()); +} + + + + + +template +inline bool +operator==(const nsCOMPtr& aLhs, decltype(nullptr)) +{ + return aLhs.get() == nullptr; +} + +template +inline bool +operator==(decltype(nullptr), const nsCOMPtr& aRhs) +{ + return nullptr == aRhs.get(); +} + +template +inline bool +operator!=(const nsCOMPtr& aLhs, decltype(nullptr)) +{ + return aLhs.get() != nullptr; +} + +template +inline bool +operator!=(decltype(nullptr), const nsCOMPtr& aRhs) +{ + return nullptr != aRhs.get(); +} + + + + +inline bool +SameCOMIdentity(nsISupports* aLhs, nsISupports* aRhs) +{ + return nsCOMPtr(do_QueryInterface(aLhs)) == + nsCOMPtr(do_QueryInterface(aRhs)); +} + + + +template +inline nsresult +CallQueryInterface(nsCOMPtr& aSourcePtr, DestinationType** aDestPtr) +{ + return CallQueryInterface(aSourcePtr.get(), aDestPtr); +} + +template +RefPtr::RefPtr(const nsCOMPtr_helper& aHelper) +{ + void* newRawPtr; + if (((bool)(__builtin_expect(!!(NS_FAILED_impl(aHelper((T::template COMTypeInfo::kIID), &newRawPtr))), 0)))) { + newRawPtr = nullptr; + } + mRawPtr = static_cast(newRawPtr); +} + +template +RefPtr& +RefPtr::operator=(const nsCOMPtr_helper& aHelper) +{ + void* newRawPtr; + if (((bool)(__builtin_expect(!!(NS_FAILED_impl(aHelper((T::template COMTypeInfo::kIID), &newRawPtr))), 0)))) { + newRawPtr = nullptr; + } + assign_assuming_AddRef(static_cast(newRawPtr)); + return *this; +} +# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAtom.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h" 1 +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h" +template struct already_AddRefed; +# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h" +class nsStringBuffer +{ +private: + friend class CheckStaticAtomSizes; + + std::atomic mRefCount; + uint32_t mStorageSize; + +public: +# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h" + static already_AddRefed Alloc(size_t aStorageSize); +# 61 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h" + static nsStringBuffer* Realloc(nsStringBuffer* aBuf, size_t aStorageSize); + + + + + void AddRef(); + + + + + + void Release(); + + + + + + + static nsStringBuffer* FromData(void* aData) + { + return reinterpret_cast(aData) - 1; + } + + + + + void* Data() const + { + return const_cast(reinterpret_cast(this + 1)); + } + + + + + + + uint32_t StorageSize() const + { + return mStorageSize; + } +# 110 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h" + bool IsReadonly() const + { +# 132 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h" + return mRefCount.load(std::memory_order_relaxed) > 1; + } +# 143 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h" + static nsStringBuffer* FromString(const nsAString& aStr); + static nsStringBuffer* FromString(const nsACString& aStr); +# 160 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h" + void ToString(uint32_t aLen, nsAString& aStr, bool aMoveOwnership = false); + void ToString(uint32_t aLen, nsACString& aStr, bool aMoveOwnership = false); + + + + + size_t SizeOfIncludingThisIfUnshared(mozilla::MallocSizeOf aMallocSizeOf) const; +# 177 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h" + size_t SizeOfIncludingThisEvenIfShared(mozilla::MallocSizeOf aMallocSizeOf) const; +}; +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAtom.h" 2 + + + + + + + + +class nsIAtom : public nsISupports { + public: + + template struct COMTypeInfo; + + + virtual nsresult ScriptableToString(nsAString & _retval) = 0; + + + virtual nsresult ToUTF8String(nsACString & _retval) = 0; + + + virtual nsresult ScriptableEquals(const nsAString & aString, bool *_retval) = 0; + + + virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) = 0; + + + inline bool Equals(char16ptr_t aString, uint32_t aLength) const + { + return mLength == aLength && + memcmp(mString, aString, mLength * sizeof(char16_t)) == 0; + } + inline bool Equals(const nsAString& aString) const { + return Equals(aString.BeginReading(), aString.Length()); + } + inline bool IsStaticAtom() const { + return mIsStatic; + } + inline char16ptr_t GetUTF16String() const { + return mString; + } + inline uint32_t GetLength() const { + return mLength; + } + inline void ToString(nsAString& aBuf) const { + + nsStringBuffer::FromData(mString)->ToString(mLength, aBuf); + } + inline nsStringBuffer* GetStringBuffer() const { + + return nsStringBuffer::FromData(mString); + } + + + + + + inline uint32_t hash() const { + return mHash; + } +protected: + uint32_t mLength:31; + uint32_t mIsStatic:1; + uint32_t mHash; + + + + + + char16_t* mString; +}; + + template struct nsIAtom::COMTypeInfo { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template const nsIID nsIAtom::COMTypeInfo::kIID __attribute__ ((visibility ("hidden"))) = {0x8b8c11d4, 0x3ed5, 0x4079, { 0x89, 0x74, 0x73, 0xc7, 0x57, 0x6c, 0xdb, 0x34 }}; +# 192 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAtom.h" +extern already_AddRefed NS_Atomize(const char* aUTF8String); + + + +extern already_AddRefed NS_Atomize(const nsACString& aUTF8String); + + + + +extern already_AddRefed NS_Atomize(const char16_t* aUTF16String); + + + +extern already_AddRefed NS_Atomize(const nsAString& aUTF16String); + + + +extern already_AddRefed NS_AtomizeMainThread(const nsAString& aUTF16String); + + + + +extern nsrefcnt NS_GetNumberOfAtoms(void); + + + + +extern nsIAtom* NS_GetStaticAtom(const nsAString& aUTF16String); + + + +extern void NS_SealStaticAtomTable(); +class nsAtomString : public nsString +{ +public: + explicit nsAtomString(const nsIAtom* aAtom) + { + aAtom->ToString(*this); + } +}; +class nsAtomCString : public nsCString +{ +public: + explicit nsAtomCString(nsIAtom* aAtom) + { + aAtom->ToUTF8String(*this); + } +}; +class nsDependentAtomString : public nsDependentString +{ +public: + explicit nsDependentAtomString(const nsIAtom* aAtom) + : nsDependentString(aAtom->GetUTF16String(), aAtom->GetLength()) + { + } +}; +# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h" 2 + +class nsIDocument; +class nsNodeInfoManager; + +namespace mozilla { +namespace dom { + +class NodeInfo final +{ +public: + public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible::value, "Reference-counted class " "NodeInfo" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); nsrefcnt count = mRefCnt.incr(static_cast(this), NodeInfo::cycleCollection::GetParticipant()); ; return count; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); nsrefcnt count = mRefCnt.decr(static_cast(this), NodeInfo::cycleCollection::GetParticipant()); ; return count; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public: + class cycleCollection : public nsCycleCollectionParticipant { public: constexpr cycleCollection () : nsCycleCollectionParticipant(true) {} private: public: virtual void Root(void *n) override; virtual void Unlink(void *n) override; virtual void Unroot(void *n) override; virtual nsresult TraverseNative(void *n, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "NodeInfo"; }; virtual void DeleteCycleCollectable(void *n) override { DowncastCCParticipant(n)->DeleteCycleCollectable(); } static NodeInfo* Downcast(void* s) { return DowncastCCParticipant(s); } static void* Upcast(NodeInfo *p) { return static_cast(p); } virtual bool CanSkipReal(void *p, bool aRemovingAllowed) override; virtual bool CanSkipInCCReal(void *p) override; virtual bool CanSkipThisReal(void *p) override; static nsCycleCollectionParticipant* GetParticipant() { return &NodeInfo::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal; + + + + + + + + void GetName(nsAString& aName) const; +# 57 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h" + nsIAtom* NameAtom() const + { + return mInner.mName; + } +# 69 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h" + const nsString& QualifiedName() const { + return mQualifiedName; + } + + + + + const nsString& NodeName() const { + return mNodeName; + } + + + + + const nsString& LocalName() const { + return mLocalName; + } + + + + + + + + void GetPrefix(nsAString& aPrefix) const; + + + + + + + + nsIAtom* GetPrefixAtom() const + { + return mInner.mPrefix; + } + + + + + void GetNamespaceURI(nsAString& aNameSpaceURI) const; + + + + + + int32_t NamespaceID() const + { + return mInner.mNamespaceID; + } + + + + + + uint16_t NodeType() const + { + return mInner.mNodeType; + } + + + + + nsIAtom* GetExtraName() const + { + return mInner.mExtraName; + } + + + + + + nsNodeInfoManager* NodeInfoManager() const + { + return mOwnerManager; + } + + + + + + + inline bool Equals(NodeInfo* aNodeInfo) const; + + bool NameAndNamespaceEquals(NodeInfo* aNodeInfo) const; + + bool Equals(nsIAtom* aNameAtom) const + { + return mInner.mName == aNameAtom; + } + + bool Equals(nsIAtom* aNameAtom, nsIAtom* aPrefixAtom) const + { + return (mInner.mName == aNameAtom) && (mInner.mPrefix == aPrefixAtom); + } + + bool Equals(nsIAtom* aNameAtom, int32_t aNamespaceID) const + { + return ((mInner.mName == aNameAtom) && + (mInner.mNamespaceID == aNamespaceID)); + } + + bool Equals(nsIAtom* aNameAtom, nsIAtom* aPrefixAtom, int32_t aNamespaceID) const + { + return ((mInner.mName == aNameAtom) && + (mInner.mPrefix == aPrefixAtom) && + (mInner.mNamespaceID == aNamespaceID)); + } + + bool NamespaceEquals(int32_t aNamespaceID) const + { + return mInner.mNamespaceID == aNamespaceID; + } + + inline bool Equals(const nsAString& aName) const; + + inline bool Equals(const nsAString& aName, const nsAString& aPrefix) const; + + inline bool Equals(const nsAString& aName, int32_t aNamespaceID) const; + + inline bool Equals(const nsAString& aName, const nsAString& aPrefix, int32_t aNamespaceID) const; + + bool NamespaceEquals(const nsAString& aNamespaceURI) const; + + inline bool QualifiedNameEquals(nsIAtom* aNameAtom) const; + + bool QualifiedNameEquals(const nsAString& aQualifiedName) const + { + return mQualifiedName == aQualifiedName; + } + + + + + nsIDocument* GetDocument() const + { + return mDocument; + } + +private: + NodeInfo() = delete; + NodeInfo(const NodeInfo& aOther) = delete; + + + + NodeInfo(nsIAtom* aName, nsIAtom* aPrefix, int32_t aNamespaceID, + uint16_t aNodeType, nsIAtom* aExtraName, + nsNodeInfoManager* aOwnerManager); + + ~NodeInfo(); + +public: + bool CanSkip(); + + + + + + void DeleteCycleCollectable(); + +protected: +# 244 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h" + class NodeInfoInner + { + public: + NodeInfoInner() + : mName(nullptr), mPrefix(nullptr), mNamespaceID(-1), + mNodeType(0), mNameString(nullptr), mExtraName(nullptr) + { + } + NodeInfoInner(nsIAtom *aName, nsIAtom *aPrefix, int32_t aNamespaceID, + uint16_t aNodeType, nsIAtom* aExtraName) + : mName(aName), mPrefix(aPrefix), mNamespaceID(aNamespaceID), + mNodeType(aNodeType), mNameString(nullptr), mExtraName(aExtraName) + { + } + NodeInfoInner(const nsAString& aTmpName, nsIAtom *aPrefix, + int32_t aNamespaceID, uint16_t aNodeType) + : mName(nullptr), mPrefix(aPrefix), mNamespaceID(aNamespaceID), + mNodeType(aNodeType), mNameString(&aTmpName), mExtraName(nullptr) + { + } + + nsCOMPtr mName; + nsCOMPtr mPrefix; + int32_t mNamespaceID; + uint16_t mNodeType; + const nsAString* mNameString; + nsCOMPtr mExtraName; + }; + + + friend class ::nsNodeInfoManager; + + + + nsIDocument* mDocument; + + NodeInfoInner mInner; + + RefPtr mOwnerManager; + + + + + + + + nsString mQualifiedName; + + + nsString mNodeName; + + + + nsString mLocalName; +}; + +} +} +# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrName.h" 2 + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDOMString.h" 1 +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDOMString.h" +inline bool DOMStringIsNull(const nsAString& aString) +{ + return aString.IsVoid(); +} + +inline void SetDOMStringToNull(nsAString& aString) +{ + aString.SetIsVoid(true); +} +# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrName.h" 2 + + +class nsAttrName +{ +public: + nsAttrName(const nsAttrName& aOther) + : mBits(aOther.mBits) + { + AddRefInternalName(); + } + + explicit nsAttrName(nsIAtom* aAtom) + : mBits(reinterpret_cast(aAtom)) + { + do { } while(0); + (aAtom)->AddRef(); + } + + explicit nsAttrName(mozilla::dom::NodeInfo* aNodeInfo) + { + do { } while(0); + if (aNodeInfo->NamespaceEquals(kNameSpaceID_None)) { + mBits = reinterpret_cast(aNodeInfo->NameAtom()); + (aNodeInfo->NameAtom())->AddRef(); + } + else { + mBits = reinterpret_cast(aNodeInfo) | + 1; + (aNodeInfo)->AddRef(); + } + } + + ~nsAttrName() + { + ReleaseInternalName(); + } + + void SetTo(mozilla::dom::NodeInfo* aNodeInfo) + { + do { } while(0); + + ReleaseInternalName(); + if (aNodeInfo->NamespaceEquals(kNameSpaceID_None)) { + mBits = reinterpret_cast(aNodeInfo->NameAtom()); + (aNodeInfo->NameAtom())->AddRef(); + } + else { + mBits = reinterpret_cast(aNodeInfo) | + 1; + (aNodeInfo)->AddRef(); + } + } + + void SetTo(nsIAtom* aAtom) + { + do { } while(0); + + ReleaseInternalName(); + mBits = reinterpret_cast(aAtom); + (aAtom)->AddRef(); + } + + bool IsAtom() const + { + return !(mBits & 1); + } + + mozilla::dom::NodeInfo* NodeInfo() const + { + do { } while(0); + return reinterpret_cast(mBits & ~1); + } + + nsIAtom* Atom() const + { + do { } while(0); + return reinterpret_cast(mBits); + } + + bool Equals(const nsAttrName& aOther) const + { + return mBits == aOther.mBits; + } + + + bool Equals(nsIAtom* aAtom) const + { + return reinterpret_cast(aAtom) == mBits; + } + + + bool Equals(const nsAString& aLocalName) const + { + return IsAtom() && Atom()->Equals(aLocalName); + } + + bool Equals(nsIAtom* aLocalName, int32_t aNamespaceID) const + { + if (aNamespaceID == kNameSpaceID_None) { + return Equals(aLocalName); + } + return !IsAtom() && NodeInfo()->Equals(aLocalName, aNamespaceID); + } + + bool Equals(mozilla::dom::NodeInfo* aNodeInfo) const + { + return Equals(aNodeInfo->NameAtom(), aNodeInfo->NamespaceID()); + } + + int32_t NamespaceID() const + { + return IsAtom() ? kNameSpaceID_None : NodeInfo()->NamespaceID(); + } + + int32_t NamespaceEquals(int32_t aNamespaceID) const + { + return aNamespaceID == kNameSpaceID_None ? + IsAtom() : + (!IsAtom() && NodeInfo()->NamespaceEquals(aNamespaceID)); + } + + nsIAtom* LocalName() const + { + return IsAtom() ? Atom() : NodeInfo()->NameAtom(); + } + + nsIAtom* GetPrefix() const + { + return IsAtom() ? nullptr : NodeInfo()->GetPrefixAtom(); + } + + bool QualifiedNameEquals(const nsAString& aName) const + { + return IsAtom() ? Atom()->Equals(aName) : + NodeInfo()->QualifiedNameEquals(aName); + } + + void GetQualifiedName(nsAString& aStr) const + { + if (IsAtom()) { + Atom()->ToString(aStr); + } + else { + aStr = NodeInfo()->QualifiedName(); + } + } + + + void GetPrefix(nsAString& aStr) const + { + if (IsAtom()) { + SetDOMStringToNull(aStr); + } + else { + NodeInfo()->GetPrefix(aStr); + } + } + + + uint32_t HashValue() const + { + + + + return mBits - 0; + } + + bool IsSmaller(nsIAtom* aOther) const + { + return mBits < reinterpret_cast(aOther); + } + +private: + + void AddRefInternalName() + { + if (IsAtom()) { + (Atom())->AddRef(); + } else { + (NodeInfo())->AddRef(); + } + } + + void ReleaseInternalName() + { + if (IsAtom()) { + Atom()->Release(); + } else { + NodeInfo()->Release(); + } + } + + uintptr_t mBits; +}; +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h" 1 +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsColor.h" 1 + + + + + + + + +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsColor.h" 2 + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h" 1 +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMathUtils.h" 1 +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMathUtils.h" +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3 +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMathUtils.h" 2 +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/float.h" 1 3 +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMathUtils.h" 2 + + + + + + + + +inline double +NS_round(double aNum) +{ + return aNum >= 0.0 ? floor(aNum + 0.5) : ceil(aNum - 0.5); +} +inline float +NS_roundf(float aNum) +{ + return aNum >= 0.0f ? floorf(aNum + 0.5f) : ceilf(aNum - 0.5f); +} +inline int32_t +NS_lround(double aNum) +{ + return aNum >= 0.0 ? int32_t(aNum + 0.5) : int32_t(aNum - 0.5); +} +# 73 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMathUtils.h" +inline int32_t +NS_lroundf(float aNum) +{ + return aNum >= 0.0f ? int32_t(aNum + 0.5f) : int32_t(aNum - 0.5f); +} + + + + + + +inline double +NS_hypot(double aNum1, double aNum2) +{ + + return __builtin_hypot(aNum1, aNum2); + + + + + +} + + + + + +inline bool +NS_finite(double aNum) +{ +# 111 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMathUtils.h" + return finite(aNum); + +} + + + + + + + +inline double +NS_floorModulo(double aNum1, double aNum2) +{ + return (aNum1 - aNum2 * floor(aNum1 / aNum2)); +} +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h" 2 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/math.h" 1 3 +# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/math.h" 3 +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3 +# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/math.h" 2 3 + +using std::abs; +using std::acos; +using std::asin; +using std::atan; +using std::atan2; +using std::cos; +using std::sin; +using std::tan; +using std::cosh; +using std::sinh; +using std::tanh; +using std::exp; +using std::frexp; +using std::ldexp; +using std::log; +using std::log10; +using std::modf; +using std::pow; +using std::sqrt; +using std::ceil; +using std::fabs; +using std::floor; +using std::fmod; + + +using std::fpclassify; +using std::isfinite; +using std::isinf; +using std::isnan; +using std::isnormal; +using std::signbit; +using std::isgreater; +using std::isgreaterequal; +using std::isless; +using std::islessequal; +using std::islessgreater; +using std::isunordered; + + + +using std::acosh; +using std::asinh; +using std::atanh; +using std::cbrt; +using std::copysign; +using std::erf; +using std::erfc; +using std::exp2; +using std::expm1; +using std::fdim; +using std::fma; +using std::fmax; +using std::fmin; +using std::hypot; +using std::ilogb; +using std::lgamma; +using std::llrint; +using std::llround; +using std::log1p; +using std::log2; +using std::logb; +using std::lrint; +using std::lround; +using std::nearbyint; +using std::nextafter; +using std::nexttoward; +using std::remainder; +using std::remquo; +using std::rint; +using std::round; +using std::scalbln; +using std::scalbn; +using std::tgamma; +using std::trunc; +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h" 2 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3 +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h" 2 +# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h" +inline float NS_IEEEPositiveInfinity() { + union { uint32_t mPRUint32; float mFloat; } pun; + pun.mPRUint32 = 0x7F800000; + return pun.mFloat; +} +inline bool NS_IEEEIsNan(float aF) { + union { uint32_t mBits; float mFloat; } pun; + pun.mFloat = aF; + return (pun.mBits & 0x7F800000) == 0x7F800000 && + (pun.mBits & 0x007FFFFF) != 0; +} + + + + + +typedef int32_t nscoord; + + + + + +inline void VERIFY_COORD(nscoord aCoord) { + + + + +} + + + + + +inline nscoord NSCoordDivRem(nscoord aSpace, size_t aN, nscoord* aQuotient) +{ + + + + + div_t result = div(aSpace, aN); + *aQuotient = nscoord(result.quot); + return nscoord(result.rem); + +} + +inline nscoord NSCoordMulDiv(nscoord aMult1, nscoord aMult2, nscoord aDiv) { + + + + return (int64_t(aMult1) * int64_t(aMult2) / int64_t(aDiv)); + +} + +inline nscoord NSToCoordRound(float aValue) +{ + + + + return nscoord(floorf(aValue + 0.5f)); + +} + +inline nscoord NSToCoordRound(double aValue) +{ + + + + return nscoord(floor(aValue + 0.5f)); + +} + +inline nscoord NSToCoordRoundWithClamp(float aValue) +{ + + + if (aValue >= nscoord(1 << 30)) { + return nscoord(1 << 30); + } + if (aValue <= (-nscoord(1 << 30))) { + return (-nscoord(1 << 30)); + } + + return NSToCoordRound(aValue); +} + + + + + + + +inline nscoord _nscoordSaturatingMultiply(nscoord aCoord, float aScale, + bool requireNotNegative) { + VERIFY_COORD(aCoord); + if (requireNotNegative) { + do { } while (0); + + } + + + + float product = aCoord * aScale; + if (requireNotNegative ? aCoord > 0 : (aCoord > 0) == (aScale > 0)) + return NSToCoordRoundWithClamp(std::min(nscoord(1 << 30), product)); + return NSToCoordRoundWithClamp(std::max((-nscoord(1 << 30)), product)); + +} + + + + + + + +inline nscoord NSCoordSaturatingNonnegativeMultiply(nscoord aCoord, float aScale) { + return _nscoordSaturatingMultiply(aCoord, aScale, true); +} + + + + + +inline nscoord NSCoordSaturatingMultiply(nscoord aCoord, float aScale) { + return _nscoordSaturatingMultiply(aCoord, aScale, false); +} +# 167 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h" +inline nscoord +NSCoordSaturatingAdd(nscoord a, nscoord b) +{ + VERIFY_COORD(a); + VERIFY_COORD(b); + + + + + + if (a == nscoord(1 << 30) || b == nscoord(1 << 30)) { + + return nscoord(1 << 30); + } else { + + + return std::min(nscoord(1 << 30), a + b); + } + +} +# 204 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h" +inline nscoord +NSCoordSaturatingSubtract(nscoord a, nscoord b, + nscoord infMinusInfResult) +{ + VERIFY_COORD(a); + VERIFY_COORD(b); + + if (b == nscoord(1 << 30)) { + if (a == nscoord(1 << 30)) { + + return infMinusInfResult; + } else { + + do { } while(0); + return 0; + } + } else { + + + + + if (a == nscoord(1 << 30)) { + + return nscoord(1 << 30); + } else { + + + return std::min(nscoord(1 << 30), a - b); + } + + } +} + +inline float NSCoordToFloat(nscoord aCoord) { + VERIFY_COORD(aCoord); + + + + return (float)aCoord; +} + + + + +inline nscoord NSToCoordFloor(float aValue) +{ + return nscoord(floorf(aValue)); +} + +inline nscoord NSToCoordFloor(double aValue) +{ + return nscoord(floor(aValue)); +} + +inline nscoord NSToCoordFloorClamped(float aValue) +{ + + + if (aValue >= nscoord(1 << 30)) { + return nscoord(1 << 30); + } + if (aValue <= (-nscoord(1 << 30))) { + return (-nscoord(1 << 30)); + } + + return NSToCoordFloor(aValue); +} + +inline nscoord NSToCoordCeil(float aValue) +{ + return nscoord(ceilf(aValue)); +} + +inline nscoord NSToCoordCeil(double aValue) +{ + return nscoord(ceil(aValue)); +} + +inline nscoord NSToCoordCeilClamped(double aValue) +{ + + + if (aValue >= nscoord(1 << 30)) { + return nscoord(1 << 30); + } + if (aValue <= (-nscoord(1 << 30))) { + return (-nscoord(1 << 30)); + } + + return NSToCoordCeil(aValue); +} + + + + + +inline nscoord NSToCoordTrunc(float aValue) +{ + + + return nscoord(aValue); +} + +inline nscoord NSToCoordTrunc(double aValue) +{ + + + return nscoord(aValue); +} + +inline nscoord NSToCoordTruncClamped(float aValue) +{ + + + if (aValue >= nscoord(1 << 30)) { + return nscoord(1 << 30); + } + if (aValue <= (-nscoord(1 << 30))) { + return (-nscoord(1 << 30)); + } + + return NSToCoordTrunc(aValue); +} + +inline nscoord NSToCoordTruncClamped(double aValue) +{ + + + if (aValue >= nscoord(1 << 30)) { + return nscoord(1 << 30); + } + if (aValue <= (-nscoord(1 << 30))) { + return (-nscoord(1 << 30)); + } + + return NSToCoordTrunc(aValue); +} + + + + +inline int32_t NSToIntFloor(float aValue) +{ + return int32_t(floorf(aValue)); +} + +inline int32_t NSToIntCeil(float aValue) +{ + return int32_t(ceilf(aValue)); +} + +inline int32_t NSToIntRound(float aValue) +{ + return NS_lroundf(aValue); +} + +inline int32_t NSToIntRound(double aValue) +{ + return NS_lround(aValue); +} + +inline int32_t NSToIntRoundUp(double aValue) +{ + return int32_t(floor(aValue + 0.5)); +} + + + + +inline nscoord NSFloatPixelsToAppUnits(float aPixels, float aAppUnitsPerPixel) +{ + return NSToCoordRoundWithClamp(aPixels * aAppUnitsPerPixel); +} + +inline nscoord NSIntPixelsToAppUnits(int32_t aPixels, int32_t aAppUnitsPerPixel) +{ + + + nscoord r = aPixels * (nscoord)aAppUnitsPerPixel; + VERIFY_COORD(r); + return r; +} + +inline float NSAppUnitsToFloatPixels(nscoord aAppUnits, float aAppUnitsPerPixel) +{ + return (float(aAppUnits) / aAppUnitsPerPixel); +} + +inline double NSAppUnitsToDoublePixels(nscoord aAppUnits, double aAppUnitsPerPixel) +{ + return (double(aAppUnits) / aAppUnitsPerPixel); +} + +inline int32_t NSAppUnitsToIntPixels(nscoord aAppUnits, float aAppUnitsPerPixel) +{ + return NSToIntRound(float(aAppUnits) / aAppUnitsPerPixel); +} + +inline float NSCoordScale(nscoord aCoord, int32_t aFromAPP, int32_t aToAPP) +{ + return (NSCoordToFloat(aCoord) * aToAPP) / aFromAPP; +} +# 418 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h" +inline float NSUnitsToTwips(float aValue, float aPointsPerUnit) +{ + return aValue * aPointsPerUnit * 20.0f; +} + +inline float NSTwipsToUnits(float aTwips, float aUnitsPerPoint) +{ + return (aTwips * (aUnitsPerPoint / 20.0f)); +} +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsColor.h" 2 + +class nsAString; +class nsString; + + + +typedef uint32_t nscolor; +# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsColor.h" +namespace mozilla { + +template +inline uint8_t ClampColor(T aColor) +{ + if (aColor >= 255) { + return 255; + } + if (aColor <= 0) { + return 0; + } + return NSToIntRound(aColor); +} + +} +# 65 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsColor.h" +enum class nsHexColorType : uint8_t { + NoAlpha, + AllowAlpha, +}; + + + + +bool +NS_HexToRGBA(const nsAString& aBuf, nsHexColorType aType, nscolor* aResult); + + + +nscolor NS_ComposeColors(nscolor aBG, nscolor aFG); + +namespace mozilla { + +inline uint32_t RoundingDivideBy255(uint32_t n) +{ + + + + return (n + 127) / 255; +} + + + +nscolor LinearBlendColors(nscolor aBg, nscolor aFg, uint_fast8_t aFgRatio); + +} + + + + +bool NS_LooseHexToRGB(const nsString& aBuf, nscolor* aResult); + + + + + + +bool NS_ColorNameToRGB(const nsAString& aBuf, nscolor* aResult); + + + +const char * const * NS_AllColorNames(size_t *aSizeArray); + + + +nscolor NS_HSL2RGB(float h, float s, float l); + + + + + + +const char* NS_RGBToColorName(nscolor aColor); +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCaseTreatment.h" 1 +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCaseTreatment.h" +enum nsCaseTreatment { + eCaseMatters, + eIgnoreCase +}; +# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMargin.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMargin.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPoint.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPoint.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseSize.h" 1 +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseSize.h" +namespace mozilla { +namespace gfx { + + + + + + +template +struct BaseSize { + union { + struct { + T width, height; + }; + T components[2]; + }; + + + constexpr BaseSize() : width(0), height(0) {} + constexpr BaseSize(T aWidth, T aHeight) : width(aWidth), height(aHeight) {} + + void SizeTo(T aWidth, T aHeight) { width = aWidth; height = aHeight; } + + bool IsEmpty() const { + return width <= 0 || height <= 0; + } + + bool IsSquare() const { + return width == height; + } + + + + + bool operator==(const Sub& aSize) const { + return width == aSize.width && height == aSize.height; + } + bool operator!=(const Sub& aSize) const { + return width != aSize.width || height != aSize.height; + } + bool operator<=(const Sub& aSize) const { + return width <= aSize.width && height <= aSize.height; + } + bool operator<(const Sub& aSize) const { + return *this <= aSize && *this != aSize; + } + + Sub operator+(const Sub& aSize) const { + return Sub(width + aSize.width, height + aSize.height); + } + Sub operator-(const Sub& aSize) const { + return Sub(width - aSize.width, height - aSize.height); + } + Sub& operator+=(const Sub& aSize) { + width += aSize.width; + height += aSize.height; + return *static_cast(this); + } + Sub& operator-=(const Sub& aSize) { + width -= aSize.width; + height -= aSize.height; + return *static_cast(this); + } + + Sub operator*(T aScale) const { + return Sub(width * aScale, height * aScale); + } + Sub operator/(T aScale) const { + return Sub(width / aScale, height / aScale); + } + friend Sub operator*(T aScale, const Sub& aSize) { + return Sub(aScale * aSize.width, aScale * aSize.height); + } + void Scale(T aXScale, T aYScale) { + width *= aXScale; + height *= aYScale; + } + + Sub operator*(const Sub& aSize) const { + return Sub(width * aSize.width, height * aSize.height); + } + Sub operator/(const Sub& aSize) const { + return Sub(width / aSize.width, height / aSize.height); + } + + friend Sub Min(const Sub& aA, const Sub& aB) { + return Sub(std::min(aA.width, aB.width), + std::min(aA.height, aB.height)); + } + + friend Sub Max(const Sub& aA, const Sub& aB) { + return Sub(std::max(aA.width, aB.width), + std::max(aA.height, aB.height)); + } + + friend std::ostream& operator<<(std::ostream& aStream, + const BaseSize& aSize) { + return aStream << aSize.width << " x " << aSize.height; + } +}; + +} +} +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPoint.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BasePoint.h" 1 + + + + + + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BasePoint.h" 2 + + + + + +namespace mozilla { +namespace gfx { + + + + + + +template +struct BasePoint { + union { + struct { + T x, y; + }; + T components[2]; + }; + + + constexpr BasePoint() : x(0), y(0) {} + constexpr BasePoint(Coord aX, Coord aY) : x(aX), y(aY) {} + + void MoveTo(T aX, T aY) { x = aX; y = aY; } + void MoveBy(T aDx, T aDy) { x += aDx; y += aDy; } + + + + + bool operator==(const Sub& aPoint) const { + return x == aPoint.x && y == aPoint.y; + } + bool operator!=(const Sub& aPoint) const { + return x != aPoint.x || y != aPoint.y; + } + + Sub operator+(const Sub& aPoint) const { + return Sub(x + aPoint.x, y + aPoint.y); + } + Sub operator-(const Sub& aPoint) const { + return Sub(x - aPoint.x, y - aPoint.y); + } + Sub& operator+=(const Sub& aPoint) { + x += aPoint.x; + y += aPoint.y; + return *static_cast(this); + } + Sub& operator-=(const Sub& aPoint) { + x -= aPoint.x; + y -= aPoint.y; + return *static_cast(this); + } + + Sub operator*(T aScale) const { + return Sub(x * aScale, y * aScale); + } + Sub operator/(T aScale) const { + return Sub(x / aScale, y / aScale); + } + + Sub operator-() const { + return Sub(-x, -y); + } + + T DotProduct(const Sub& aPoint) const { + return x * aPoint.x + y * aPoint.y; + } + + Coord Length() const { + return hypot(x, y); + } + + T LengthSquare() const { + return x * x + y * y; + } + + + + + Sub& Round() { + x = Coord(floor(T(x) + T(0.5))); + y = Coord(floor(T(y) + T(0.5))); + return *static_cast(this); + } + + + bool IsFinite() const + { + typedef typename mozilla::Conditional::value, float, double>::Type FloatType; + return (mozilla::IsFinite(FloatType(x)) && mozilla::IsFinite(FloatType(y))); + return true; + } + + void Clamp(T aMaxAbsValue) + { + x = std::max(std::min(x, aMaxAbsValue), -aMaxAbsValue); + y = std::max(std::min(y, aMaxAbsValue), -aMaxAbsValue); + } + + friend std::ostream& operator<<(std::ostream& stream, const BasePoint& aPoint) { + return stream << '(' << aPoint.x << ',' << aPoint.y << ')'; + } + +}; + +} +} +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPoint.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSize.h" 1 +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSize.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h" 1 +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h" +# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h" 2 + + +namespace mozilla { +namespace gfx { + +typedef float Float; + +enum class SurfaceType : int8_t { + DATA, + D2D1_BITMAP, + D2D1_DRAWTARGET, + CAIRO, + CAIRO_IMAGE, + COREGRAPHICS_IMAGE, + COREGRAPHICS_CGCONTEXT, + SKIA, + DUAL_DT, + D2D1_1_IMAGE, + RECORDING, + TILED, + DATA_SHARED, +}; + +enum class SurfaceFormat : int8_t { + + + + + B8G8R8A8, + B8G8R8X8, + R8G8B8A8, + R8G8B8X8, + A8R8G8B8, + X8R8G8B8, + + R8G8B8, + B8G8R8, + + + + + R5G6B5_UINT16, + + + A8, + + + YUV, + NV12, + YUV422, + HSV, + Lab, + Depth, + + + UNKNOWN, + + + + + + A8R8G8B8_UINT32 = B8G8R8A8, + X8R8G8B8_UINT32 = B8G8R8X8 + + + + + + +}; + +inline bool IsOpaque(SurfaceFormat aFormat) +{ + switch (aFormat) { + case SurfaceFormat::B8G8R8X8: + case SurfaceFormat::R8G8B8X8: + case SurfaceFormat::R5G6B5_UINT16: + case SurfaceFormat::YUV: + case SurfaceFormat::NV12: + case SurfaceFormat::YUV422: + return true; + default: + return false; + } +} + +enum class FilterType : int8_t { + BLEND = 0, + TRANSFORM, + MORPHOLOGY, + COLOR_MATRIX, + FLOOD, + TILE, + TABLE_TRANSFER, + DISCRETE_TRANSFER, + LINEAR_TRANSFER, + GAMMA_TRANSFER, + CONVOLVE_MATRIX, + DISPLACEMENT_MAP, + TURBULENCE, + ARITHMETIC_COMBINE, + COMPOSITE, + DIRECTIONAL_BLUR, + GAUSSIAN_BLUR, + POINT_DIFFUSE, + POINT_SPECULAR, + SPOT_DIFFUSE, + SPOT_SPECULAR, + DISTANT_DIFFUSE, + DISTANT_SPECULAR, + CROP, + PREMULTIPLY, + UNPREMULTIPLY +}; + +enum class DrawTargetType : int8_t { + SOFTWARE_RASTER = 0, + HARDWARE_RASTER, + VECTOR +}; + +enum class BackendType : int8_t { + NONE = 0, + DIRECT2D, + CAIRO, + SKIA, + RECORDING, + DIRECT2D1_1, + + + BACKEND_LAST +}; + +enum class FontType : int8_t { + DWRITE, + GDI, + MAC, + SKIA, + CAIRO, + COREGRAPHICS, + FONTCONFIG +}; + +enum class NativeSurfaceType : int8_t { + D3D10_TEXTURE, + CAIRO_CONTEXT, + CGCONTEXT, + CGCONTEXT_ACCELERATED, + OPENGL_TEXTURE +}; + +enum class NativeFontType : int8_t { + DWRITE_FONT_FACE, + GDI_FONT_FACE, + MAC_FONT_FACE, + SKIA_FONT_FACE, + CAIRO_FONT_FACE +}; + +enum class FontStyle : int8_t { + NORMAL, + ITALIC, + BOLD, + BOLD_ITALIC +}; + +enum class FontHinting : int8_t { + NONE, + LIGHT, + NORMAL, + FULL +}; + +enum class CompositionOp : int8_t { + OP_OVER, + OP_ADD, + OP_ATOP, + OP_OUT, + OP_IN, + OP_SOURCE, + OP_DEST_IN, + OP_DEST_OUT, + OP_DEST_OVER, + OP_DEST_ATOP, + OP_XOR, + OP_MULTIPLY, + OP_SCREEN, + OP_OVERLAY, + OP_DARKEN, + OP_LIGHTEN, + OP_COLOR_DODGE, + OP_COLOR_BURN, + OP_HARD_LIGHT, + OP_SOFT_LIGHT, + OP_DIFFERENCE, + OP_EXCLUSION, + OP_HUE, + OP_SATURATION, + OP_COLOR, + OP_LUMINOSITY, + OP_COUNT +}; + +enum class Axis : int8_t { + X_AXIS, + Y_AXIS, + BOTH +}; + +enum class ExtendMode : int8_t { + CLAMP, + REPEAT, + REPEAT_X, + REPEAT_Y, + REFLECT +}; + +enum class FillRule : int8_t { + FILL_WINDING, + FILL_EVEN_ODD +}; + +enum class AntialiasMode : int8_t { + NONE, + GRAY, + SUBPIXEL, + DEFAULT +}; + + +enum class SamplingFilter : int8_t { + GOOD, + LINEAR, + POINT, + SENTINEL +}; + +enum class PatternType : int8_t { + COLOR, + SURFACE, + LINEAR_GRADIENT, + RADIAL_GRADIENT +}; + +enum class JoinStyle : int8_t { + BEVEL, + ROUND, + MITER, + + + MITER_OR_BEVEL +}; + +enum class CapStyle : int8_t { + BUTT, + ROUND, + SQUARE +}; + +enum class SamplingBounds : int8_t { + UNBOUNDED, + BOUNDED +}; + + +struct Color +{ +public: + Color() + : r(0.0f), g(0.0f), b(0.0f), a(0.0f) + {} + Color(Float aR, Float aG, Float aB, Float aA) + : r(aR), g(aG), b(aB), a(aA) + {} + Color(Float aR, Float aG, Float aB) + : r(aR), g(aG), b(aB), a(1.0f) + {} + + static Color FromABGR(uint32_t aColor) + { + Color newColor(((aColor >> 0) & 0xff) * (1.0f / 255.0f), + ((aColor >> 8) & 0xff) * (1.0f / 255.0f), + ((aColor >> 16) & 0xff) * (1.0f / 255.0f), + ((aColor >> 24) & 0xff) * (1.0f / 255.0f)); + + return newColor; + } + + + + static Color UnusualFromARGB(uint32_t aColor) + { + Color newColor(((aColor >> 16) & 0xff) * (1.0f / 255.0f), + ((aColor >> 8) & 0xff) * (1.0f / 255.0f), + ((aColor >> 0) & 0xff) * (1.0f / 255.0f), + ((aColor >> 24) & 0xff) * (1.0f / 255.0f)); + + return newColor; + } + + uint32_t ToABGR() const + { + return uint32_t(r * 255.0f) | uint32_t(g * 255.0f) << 8 | + uint32_t(b * 255.0f) << 16 | uint32_t(a * 255.0f) << 24; + } + + + + uint32_t UnusualToARGB() const + { + return uint32_t(b * 255.0f) | uint32_t(g * 255.0f) << 8 | + uint32_t(r * 255.0f) << 16 | uint32_t(a * 255.0f) << 24; + } + + bool operator==(const Color& aColor) const { + return r == aColor.r && g == aColor.g && b == aColor.b && a == aColor.a; + } + + bool operator!=(const Color& aColor) const { + return !(*this == aColor); + } + + Float r, g, b, a; +}; + +struct GradientStop +{ + bool operator<(const GradientStop& aOther) const { + return offset < aOther.offset; + } + + Float offset; + Color color; +}; + +enum class JobStatus { + Complete, + Wait, + Yield, + Error +}; + +} +} + + +typedef mozilla::gfx::SurfaceFormat gfxImageFormat; +# 371 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h" +namespace mozilla { + + +enum Side { eSideTop, eSideRight, eSideBottom, eSideLeft }; + +enum SideBits { + eSideBitsNone = 0, + eSideBitsTop = 1 << eSideTop, + eSideBitsRight = 1 << eSideRight, + eSideBitsBottom = 1 << eSideBottom, + eSideBitsLeft = 1 << eSideLeft, + eSideBitsTopBottom = eSideBitsTop | eSideBitsBottom, + eSideBitsLeftRight = eSideBitsLeft | eSideBitsRight, + eSideBitsAll = eSideBitsTopBottom | eSideBitsLeftRight +}; +# 398 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h" +static inline Side& operator++(Side& side) { + do { } while (0); + + side = Side(side + 1); + return side; +} + +enum Corner { + + eCornerTopLeft = 0, + eCornerTopRight = 1, + eCornerBottomRight = 2, + eCornerBottomLeft = 3 +}; + + + + +constexpr int eCornerCount = 4; +# 427 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h" +static inline Corner operator++(Corner& aCorner) { + do { } while (0); + + aCorner = Corner(aCorner + 1); + return aCorner; +} + + +enum HalfCorner { + + eCornerTopLeftX = 0, + eCornerTopLeftY = 1, + eCornerTopRightX = 2, + eCornerTopRightY = 3, + eCornerBottomRightX = 4, + eCornerBottomRightY = 5, + eCornerBottomLeftX = 6, + eCornerBottomLeftY = 7 +}; +# 456 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h" +static inline HalfCorner operator++(HalfCorner& aHalfCorner) { + do { } while (0); + + aHalfCorner = HalfCorner(aHalfCorner + 1); + return aHalfCorner; +} + + + + +constexpr bool HalfCornerIsX(HalfCorner aHalfCorner) +{ + return !(aHalfCorner % 2); +} + +constexpr Corner HalfToFullCorner(HalfCorner aHalfCorner) +{ + return Corner(aHalfCorner / 2); +} + +constexpr HalfCorner FullToHalfCorner(Corner aCorner, bool aIsVertical) +{ + return HalfCorner(aCorner * 2 + aIsVertical); +} + +constexpr bool SideIsVertical(Side aSide) +{ + return aSide % 2; +} + + + + + +constexpr Corner SideToFullCorner(Side aSide, bool aIsSecond) +{ + return Corner((aSide + aIsSecond) % 4); +} +# 502 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h" +constexpr HalfCorner SideToHalfCorner(Side aSide, bool aIsSecond, + bool aIsParallel) +{ + return HalfCorner(((aSide + aIsSecond) * 2 + (aSide + !aIsParallel) % 2) % 8); +} + +} +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Coord.h" 1 +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Coord.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseCoord.h" 1 +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseCoord.h" +namespace mozilla { +namespace gfx { + + + + + + +template +struct BaseCoord { + T value; + + + constexpr BaseCoord() : value(0) {} + explicit constexpr BaseCoord(T aValue) : value(aValue) {} + + + + + operator T() const { return value; } + + friend bool operator==(Sub aA, Sub aB) { + return aA.value == aB.value; + } + friend bool operator!=(Sub aA, Sub aB) { + return aA.value != aB.value; + } + + friend Sub operator+(Sub aA, Sub aB) { + return Sub(aA.value + aB.value); + } + friend Sub operator-(Sub aA, Sub aB) { + return Sub(aA.value - aB.value); + } + friend Sub operator*(Sub aCoord, T aScale) { + return Sub(aCoord.value * aScale); + } + friend Sub operator*(T aScale, Sub aCoord) { + return Sub(aScale * aCoord.value); + } + friend Sub operator/(Sub aCoord, T aScale) { + return Sub(aCoord.value / aScale); + } + + + Sub& operator+=(Sub aCoord) { + value += aCoord.value; + return *static_cast(this); + } + Sub& operator-=(Sub aCoord) { + value -= aCoord.value; + return *static_cast(this); + } + Sub& operator*=(T aScale) { + value *= aScale; + return *static_cast(this); + } + Sub& operator/=(T aScale) { + value /= aScale; + return *static_cast(this); + } + + + + + + friend bool operator==(Sub aA, T aB) { + return aA.value == aB; + } + friend bool operator==(T aA, Sub aB) { + return aA == aB.value; + } + friend bool operator!=(Sub aA, T aB) { + return aA.value != aB; + } + friend bool operator!=(T aA, Sub aB) { + return aA != aB.value; + } + friend T operator+(Sub aA, T aB) { + return aA.value + aB; + } + friend T operator+(T aA, Sub aB) { + return aA + aB.value; + } + friend T operator-(Sub aA, T aB) { + return aA.value - aB; + } + friend T operator-(T aA, Sub aB) { + return aA - aB.value; + } + + Sub operator-() const { + return Sub(-value); + } +}; + +} +} +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Coord.h" 2 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3 +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Coord.h" 2 + +namespace mozilla { + +template struct IsPixel; + +namespace gfx { + +template struct IntCoordTyped; +template struct CoordTyped; +# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Coord.h" +template +struct CommonType; + +template +struct CommonType, primitive> { + typedef decltype(int32_t() + primitive()) type; +}; + +template +struct CommonType, primitive> { + typedef decltype(F() + primitive()) type; +}; +# 53 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Coord.h" +template +struct CoordOperatorsHelper { + + +}; + +template +struct CoordOperatorsHelper { + friend bool operator==(coord aA, primitive aB) { + return aA.value == aB; + } + friend bool operator==(primitive aA, coord aB) { + return aA == aB.value; + } + friend bool operator!=(coord aA, primitive aB) { + return aA.value != aB; + } + friend bool operator!=(primitive aA, coord aB) { + return aA != aB.value; + } + + typedef typename CommonType::type result_type; + + friend result_type operator+(coord aA, primitive aB) { + return aA.value + aB; + } + friend result_type operator+(primitive aA, coord aB) { + return aA + aB.value; + } + friend result_type operator-(coord aA, primitive aB) { + return aA.value - aB; + } + friend result_type operator-(primitive aA, coord aB) { + return aA - aB.value; + } + friend result_type operator*(coord aCoord, primitive aScale) { + return aCoord.value * aScale; + } + friend result_type operator*(primitive aScale, coord aCoord) { + return aScale * aCoord.value; + } + friend result_type operator/(coord aCoord, primitive aScale) { + return aCoord.value / aScale; + } + +}; + + + + +template +struct IntCoordTyped : + public BaseCoord< int32_t, IntCoordTyped >, + public CoordOperatorsHelper< true, IntCoordTyped, float >, + public CoordOperatorsHelper< true, IntCoordTyped, double > { + static_assert(IsPixel::value, + "'units' must be a coordinate system tag"); + + typedef BaseCoord< int32_t, IntCoordTyped > Super; + + constexpr IntCoordTyped() : Super() {} + constexpr IntCoordTyped(int32_t aValue) : Super(aValue) {} +}; + +template +struct CoordTyped : + public BaseCoord< F, CoordTyped >, + public CoordOperatorsHelper< !IsSame::value, CoordTyped, int32_t >, + public CoordOperatorsHelper< !IsSame::value, CoordTyped, uint32_t >, + public CoordOperatorsHelper< !IsSame::value, CoordTyped, double >, + public CoordOperatorsHelper< !IsSame::value, CoordTyped, float > { + static_assert(IsPixel::value, + "'units' must be a coordinate system tag"); + + typedef BaseCoord< F, CoordTyped > Super; + + constexpr CoordTyped() : Super() {} + constexpr CoordTyped(F aValue) : Super(aValue) {} + explicit constexpr CoordTyped(const IntCoordTyped& aCoord) : Super(F(aCoord.value)) {} + + void Round() { + this->value = floor(this->value + 0.5); + } + void Truncate() { + this->value = int32_t(this->value); + } + + IntCoordTyped Rounded() const { + return IntCoordTyped(int32_t(floor(this->value + 0.5))); + } + IntCoordTyped Truncated() const { + return IntCoordTyped(int32_t(this->value)); + } +}; + +} +} +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h" 2 + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BasePoint3D.h" 1 +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BasePoint3D.h" +namespace mozilla { +namespace gfx { + + + + + + +template +struct BasePoint3D { + union { + struct { + T x, y, z; + }; + T components[3]; + }; + + + BasePoint3D() : x(0), y(0), z(0) {} + BasePoint3D(T aX, T aY, T aZ) : x(aX), y(aY), z(aZ) {} + + void MoveTo(T aX, T aY, T aZ) { x = aX; y = aY; z = aZ; } + void MoveBy(T aDx, T aDy, T aDz) { x += aDx; y += aDy; z += aDz; } + + + + + T& operator[](int aIndex) { + do { } while (0); + return *((&x)+aIndex); + } + + const T& operator[](int aIndex) const { + do { } while (0); + return *((&x)+aIndex); + } + + bool operator==(const Sub& aPoint) const { + return x == aPoint.x && y == aPoint.y && z == aPoint.z; + } + bool operator!=(const Sub& aPoint) const { + return x != aPoint.x || y != aPoint.y || z != aPoint.z; + } + + Sub operator+(const Sub& aPoint) const { + return Sub(x + aPoint.x, y + aPoint.y, z + aPoint.z); + } + Sub operator-(const Sub& aPoint) const { + return Sub(x - aPoint.x, y - aPoint.y, z - aPoint.z); + } + Sub& operator+=(const Sub& aPoint) { + x += aPoint.x; + y += aPoint.y; + z += aPoint.z; + return *static_cast(this); + } + Sub& operator-=(const Sub& aPoint) { + x -= aPoint.x; + y -= aPoint.y; + z -= aPoint.z; + return *static_cast(this); + } + + Sub operator*(T aScale) const { + return Sub(x * aScale, y * aScale, z * aScale); + } + Sub operator/(T aScale) const { + return Sub(x / aScale, y / aScale, z / aScale); + } + + Sub& operator*=(T aScale) { + x *= aScale; + y *= aScale; + z *= aScale; + return *static_cast(this); + } + + Sub& operator/=(T aScale) { + x /= aScale; + y /= aScale; + z /= aScale; + return *static_cast(this); + } + + Sub operator-() const { + return Sub(-x, -y, -z); + } + + Sub CrossProduct(const Sub& aPoint) const { + return Sub(y * aPoint.z - aPoint.y * z, + z * aPoint.x - aPoint.z * x, + x * aPoint.y - aPoint.x * y); + } + + T DotProduct(const Sub& aPoint) const { + return x * aPoint.x + y * aPoint.y + z * aPoint.z; + } + + T Length() const { + return sqrt(x*x + y*y + z*z); + } + + + void Normalize() { + *this /= Length(); + } +}; + +} +} +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BasePoint4D.h" 1 +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BasePoint4D.h" +namespace mozilla { +namespace gfx { + + + + + + +template +struct BasePoint4D { + union { + struct { + T x, y, z, w; + }; + T components[4]; + }; + + + BasePoint4D() : x(0), y(0), z(0), w(0) {} + BasePoint4D(T aX, T aY, T aZ, T aW) : x(aX), y(aY), z(aZ), w(aW) {} + + void MoveTo(T aX, T aY, T aZ, T aW) { x = aX; y = aY; z = aZ; w = aW; } + void MoveBy(T aDx, T aDy, T aDz, T aDw) { x += aDx; y += aDy; z += aDz; w += aDw; } + + + + + bool operator==(const Sub& aPoint) const { + return x == aPoint.x && y == aPoint.y && + z == aPoint.z && w == aPoint.w; + } + bool operator!=(const Sub& aPoint) const { + return x != aPoint.x || y != aPoint.y || + z != aPoint.z || w != aPoint.w; + } + + Sub operator+(const Sub& aPoint) const { + return Sub(x + aPoint.x, y + aPoint.y, z + aPoint.z, w + aPoint.w); + } + Sub operator-(const Sub& aPoint) const { + return Sub(x - aPoint.x, y - aPoint.y, z - aPoint.z, w - aPoint.w); + } + Sub& operator+=(const Sub& aPoint) { + x += aPoint.x; + y += aPoint.y; + z += aPoint.z; + w += aPoint.w; + return *static_cast(this); + } + Sub& operator-=(const Sub& aPoint) { + x -= aPoint.x; + y -= aPoint.y; + z -= aPoint.z; + w -= aPoint.w; + return *static_cast(this); + } + + Sub operator*(T aScale) const { + return Sub(x * aScale, y * aScale, z * aScale, w * aScale); + } + Sub operator/(T aScale) const { + return Sub(x / aScale, y / aScale, z / aScale, w / aScale); + } + + Sub& operator*=(T aScale) { + x *= aScale; + y *= aScale; + z *= aScale; + w *= aScale; + return *static_cast(this); + } + + Sub& operator/=(T aScale) { + x /= aScale; + y /= aScale; + z /= aScale; + w /= aScale; + return *static_cast(this); + } + + Sub operator-() const { + return Sub(-x, -y, -z, -w); + } + + T& operator[](int aIndex) { + do { } while (0); + return *((&x)+aIndex); + } + + const T& operator[](int aIndex) const { + do { } while (0); + return *((&x)+aIndex); + } + + T DotProduct(const Sub& aPoint) const { + return x * aPoint.x + y * aPoint.y + z * aPoint.z + w * aPoint.w; + } + + + Sub CrossProduct(const Sub& aPoint) const { + return Sub(y * aPoint.z - aPoint.y * z, + z * aPoint.x - aPoint.z * x, + x * aPoint.y - aPoint.x * y, + 0); + } + + T Length() const { + return sqrt(x*x + y*y + z*z + w*w); + } + + void Normalize() { + *this /= Length(); + } + + bool HasPositiveWCoord() { return w > 0; } +}; + +} +} +# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h" 2 + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3 +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h" 2 + +namespace mozilla { + +template struct IsPixel; + +namespace gfx { + + +struct UnknownUnits {}; + +} + +template<> struct IsPixel : TrueType {}; + +namespace gfx { + + + + + + +template +struct IntParam { + constexpr IntParam(char val) : value(val) {} + constexpr IntParam(unsigned char val) : value(val) {} + constexpr IntParam(short val) : value(val) {} + constexpr IntParam(unsigned short val) : value(val) {} + constexpr IntParam(int val) : value(val) {} + constexpr IntParam(unsigned int val) : value(val) {} + constexpr IntParam(long val) : value(val) {} + constexpr IntParam(unsigned long val) : value(val) {} + constexpr IntParam(long long val) : value(val) {} + constexpr IntParam(unsigned long long val) : value(val) {} + template + constexpr IntParam(IntCoordTyped val) : value(val) {} + + + IntParam(float val) = delete; + IntParam(double val) = delete; + + T value; +}; + +template struct PointTyped; +template struct SizeTyped; + +template +struct IntPointTyped : + public BasePoint< int32_t, IntPointTyped, IntCoordTyped >, + public units { + static_assert(IsPixel::value, + "'units' must be a coordinate system tag"); + + typedef IntParam ToInt; + typedef IntCoordTyped Coord; + typedef BasePoint< int32_t, IntPointTyped, IntCoordTyped > Super; + + constexpr IntPointTyped() : Super() {} + constexpr IntPointTyped(ToInt aX, ToInt aY) : Super(Coord(aX.value), Coord(aY.value)) {} + + static IntPointTyped Round(float aX, float aY) { + return IntPointTyped(int32_t(floorf(aX + 0.5)), int32_t(floorf(aY + 0.5))); + } + + static IntPointTyped Ceil(float aX, float aY) { + return IntPointTyped(int32_t(ceil(aX)), int32_t(ceil(aY))); + } + + static IntPointTyped Floor(float aX, float aY) { + return IntPointTyped(int32_t(floorf(aX)), int32_t(floorf(aY))); + } + + static IntPointTyped Truncate(float aX, float aY) { + return IntPointTyped(int32_t(aX), int32_t(aY)); + } + + static IntPointTyped Round(const PointTyped& aPoint); + static IntPointTyped Ceil(const PointTyped& aPoint); + static IntPointTyped Floor(const PointTyped& aPoint); + static IntPointTyped Truncate(const PointTyped& aPoint); + + + + + static IntPointTyped FromUnknownPoint(const IntPointTyped& aPoint) { + return IntPointTyped(aPoint.x, aPoint.y); + } + + IntPointTyped ToUnknownPoint() const { + return IntPointTyped(this->x, this->y); + } +}; +typedef IntPointTyped IntPoint; + +template +struct PointTyped : + public BasePoint< F, PointTyped, CoordTyped >, + public units { + static_assert(IsPixel::value, + "'units' must be a coordinate system tag"); + + typedef CoordTyped Coord; + typedef BasePoint< F, PointTyped, CoordTyped > Super; + + constexpr PointTyped() : Super() {} + constexpr PointTyped(F aX, F aY) : Super(Coord(aX), Coord(aY)) {} + + + constexpr PointTyped(F aX, Coord aY) : Super(Coord(aX), aY) {} + constexpr PointTyped(Coord aX, F aY) : Super(aX, Coord(aY)) {} + constexpr PointTyped(Coord aX, Coord aY) : Super(aX.value, aY.value) {} + constexpr PointTyped(const IntPointTyped& point) : Super(F(point.x), F(point.y)) {} + + + + + static PointTyped FromUnknownPoint(const PointTyped& aPoint) { + return PointTyped(aPoint.x, aPoint.y); + } + + PointTyped ToUnknownPoint() const { + return PointTyped(this->x, this->y); + } +}; +typedef PointTyped Point; +typedef PointTyped PointDouble; + +template +IntPointTyped RoundedToInt(const PointTyped& aPoint) { + return IntPointTyped::Round(aPoint.x, aPoint.y); +} + +template +IntPointTyped TruncatedToInt(const PointTyped& aPoint) { + return IntPointTyped::Truncate(aPoint.x, aPoint.y); +} + +template +struct Point3DTyped : + public BasePoint3D< F, Point3DTyped > { + static_assert(IsPixel::value, + "'units' must be a coordinate system tag"); + + typedef BasePoint3D< F, Point3DTyped > Super; + + Point3DTyped() : Super() {} + Point3DTyped(F aX, F aY, F aZ) : Super(aX, aY, aZ) {} + + + + + static Point3DTyped FromUnknownPoint(const Point3DTyped& aPoint) { + return Point3DTyped(aPoint.x, aPoint.y, aPoint.z); + } + + Point3DTyped ToUnknownPoint() const { + return Point3DTyped(this->x, this->y, this->z); + } +}; +typedef Point3DTyped Point3D; +typedef Point3DTyped PointDouble3D; + +template +IntPointTyped +IntPointTyped::Round(const PointTyped& aPoint) +{ + return IntPointTyped::Round(aPoint.x, aPoint.y); +} + +template +IntPointTyped +IntPointTyped::Ceil(const PointTyped& aPoint) +{ + return IntPointTyped::Ceil(aPoint.x, aPoint.y); +} + +template +IntPointTyped +IntPointTyped::Floor(const PointTyped& aPoint) +{ + return IntPointTyped::Floor(aPoint.x, aPoint.y); +} + +template +IntPointTyped +IntPointTyped::Truncate(const PointTyped& aPoint) +{ + return IntPointTyped::Truncate(aPoint.x, aPoint.y); +} + +template +struct Point4DTyped : + public BasePoint4D< F, Point4DTyped > { + static_assert(IsPixel::value, + "'units' must be a coordinate system tag"); + + typedef BasePoint4D< F, Point4DTyped > Super; + + Point4DTyped() : Super() {} + Point4DTyped(F aX, F aY, F aZ, F aW) : Super(aX, aY, aZ, aW) {} + + explicit Point4DTyped(const Point3DTyped& aPoint) + : Super(aPoint.x, aPoint.y, aPoint.z, 1) {} + + + + + static Point4DTyped FromUnknownPoint(const Point4DTyped& aPoint) { + return Point4DTyped(aPoint.x, aPoint.y, aPoint.z, aPoint.w); + } + + Point4DTyped ToUnknownPoint() const { + return Point4DTyped(this->x, this->y, this->z, this->w); + } + + PointTyped As2DPoint() const { + return PointTyped(this->x / this->w, + this->y / this->w); + } + + Point3DTyped As3DPoint() const { + return Point3DTyped(this->x / this->w, + this->y / this->w, + this->z / this->w); + } +}; +typedef Point4DTyped Point4D; +typedef Point4DTyped PointDouble4D; + +template +struct IntSizeTyped : + public BaseSize< int32_t, IntSizeTyped >, + public units { + static_assert(IsPixel::value, + "'units' must be a coordinate system tag"); + + typedef IntParam ToInt; + typedef BaseSize< int32_t, IntSizeTyped > Super; + + constexpr IntSizeTyped() : Super() {} + constexpr IntSizeTyped(ToInt aWidth, ToInt aHeight) : Super(aWidth.value, aHeight.value) {} + + static IntSizeTyped Round(float aWidth, float aHeight) { + return IntSizeTyped(int32_t(floorf(aWidth + 0.5)), int32_t(floorf(aHeight + 0.5))); + } + + static IntSizeTyped Truncate(float aWidth, float aHeight) { + return IntSizeTyped(int32_t(aWidth), int32_t(aHeight)); + } + + static IntSizeTyped Ceil(float aWidth, float aHeight) { + return IntSizeTyped(int32_t(ceil(aWidth)), int32_t(ceil(aHeight))); + } + + static IntSizeTyped Floor(float aWidth, float aHeight) { + return IntSizeTyped(int32_t(floorf(aWidth)), int32_t(floorf(aHeight))); + } + + static IntSizeTyped Round(const SizeTyped& aSize); + static IntSizeTyped Ceil(const SizeTyped& aSize); + static IntSizeTyped Floor(const SizeTyped& aSize); + static IntSizeTyped Truncate(const SizeTyped& aSize); + + + + + static IntSizeTyped FromUnknownSize(const IntSizeTyped& aSize) { + return IntSizeTyped(aSize.width, aSize.height); + } + + IntSizeTyped ToUnknownSize() const { + return IntSizeTyped(this->width, this->height); + } +}; +typedef IntSizeTyped IntSize; + +template +struct SizeTyped : + public BaseSize< F, SizeTyped >, + public units { + static_assert(IsPixel::value, + "'units' must be a coordinate system tag"); + + typedef BaseSize< F, SizeTyped > Super; + + constexpr SizeTyped() : Super() {} + constexpr SizeTyped(F aWidth, F aHeight) : Super(aWidth, aHeight) {} + explicit SizeTyped(const IntSizeTyped& size) : + Super(F(size.width), F(size.height)) {} + + + + + static SizeTyped FromUnknownSize(const SizeTyped& aSize) { + return SizeTyped(aSize.width, aSize.height); + } + + SizeTyped ToUnknownSize() const { + return SizeTyped(this->width, this->height); + } +}; +typedef SizeTyped Size; +typedef SizeTyped SizeDouble; + +template +IntSizeTyped RoundedToInt(const SizeTyped& aSize) { + return IntSizeTyped(int32_t(floorf(aSize.width + 0.5f)), + int32_t(floorf(aSize.height + 0.5f))); +} + +template IntSizeTyped +IntSizeTyped::Round(const SizeTyped& aSize) { + return IntSizeTyped::Round(aSize.width, aSize.height); +} + +template IntSizeTyped +IntSizeTyped::Ceil(const SizeTyped& aSize) { + return IntSizeTyped::Ceil(aSize.width, aSize.height); +} + +template IntSizeTyped +IntSizeTyped::Floor(const SizeTyped& aSize) { + return IntSizeTyped::Floor(aSize.width, aSize.height); +} + +template IntSizeTyped +IntSizeTyped::Truncate(const SizeTyped& aSize) { + return IntSizeTyped::Truncate(aSize.width, aSize.height); +} + +} +} +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSize.h" 2 + + + + +typedef mozilla::gfx::IntSize nsIntSize; + +struct nsSize : public mozilla::gfx::BaseSize { + typedef mozilla::gfx::BaseSize Super; + + nsSize() : Super() {} + nsSize(nscoord aWidth, nscoord aHeight) : Super(aWidth, aHeight) {} + + inline mozilla::gfx::IntSize ScaleToNearestPixels(float aXScale, float aYScale, + nscoord aAppUnitsPerPixel) const; + inline mozilla::gfx::IntSize ToNearestPixels(nscoord aAppUnitsPerPixel) const; + + + + + + + __attribute__ ((warn_unused_result)) inline nsSize + ScaleToOtherAppUnits(int32_t aFromAPP, int32_t aToAPP) const; +}; + +inline mozilla::gfx::IntSize +nsSize::ScaleToNearestPixels(float aXScale, float aYScale, + nscoord aAppUnitsPerPixel) const +{ + return mozilla::gfx::IntSize( + NSToIntRoundUp(NSAppUnitsToDoublePixels(width, aAppUnitsPerPixel) * aXScale), + NSToIntRoundUp(NSAppUnitsToDoublePixels(height, aAppUnitsPerPixel) * aYScale)); +} + +inline mozilla::gfx::IntSize +nsSize::ToNearestPixels(nscoord aAppUnitsPerPixel) const +{ + return ScaleToNearestPixels(1.0f, 1.0f, aAppUnitsPerPixel); +} + +inline nsSize +nsSize::ScaleToOtherAppUnits(int32_t aFromAPP, int32_t aToAPP) const { + if (aFromAPP != aToAPP) { + nsSize size; + size.width = NSToCoordRound(NSCoordScale(width, aFromAPP, aToAPP)); + size.height = NSToCoordRound(NSCoordScale(height, aFromAPP, aToAPP)); + return size; + } + return *this; +} + +inline nsSize +IntSizeToAppUnits(mozilla::gfx::IntSize aSize, nscoord aAppUnitsPerPixel) +{ + return nsSize(NSIntPixelsToAppUnits(aSize.width, aAppUnitsPerPixel), + NSIntPixelsToAppUnits(aSize.height, aAppUnitsPerPixel)); +} +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPoint.h" 2 + + + + + +typedef mozilla::gfx::IntPoint nsIntPoint; + + + +struct nsPoint : public mozilla::gfx::BasePoint { + typedef mozilla::gfx::BasePoint Super; + + nsPoint() : Super() {} + nsPoint(const nsPoint& aPoint) : Super(aPoint) {} + nsPoint(nscoord aX, nscoord aY) : Super(aX, aY) {} + + inline nsIntPoint ScaleToNearestPixels(float aXScale, float aYScale, + nscoord aAppUnitsPerPixel) const; + inline nsIntPoint ToNearestPixels(nscoord aAppUnitsPerPixel) const; + + + + + + + __attribute__ ((warn_unused_result)) inline nsPoint + ScaleToOtherAppUnits(int32_t aFromAPP, int32_t aToAPP) const; + + __attribute__ ((warn_unused_result)) inline nsPoint + RemoveResolution(const float resolution) const; + __attribute__ ((warn_unused_result)) inline nsPoint + ApplyResolution(const float resolution) const; +}; + +inline nsPoint ToAppUnits(const nsIntPoint& aPoint, nscoord aAppUnitsPerPixel); + +inline nsIntPoint +nsPoint::ScaleToNearestPixels(float aXScale, float aYScale, + nscoord aAppUnitsPerPixel) const +{ + return nsIntPoint( + NSToIntRoundUp(NSAppUnitsToDoublePixels(x, aAppUnitsPerPixel) * aXScale), + NSToIntRoundUp(NSAppUnitsToDoublePixels(y, aAppUnitsPerPixel) * aYScale)); +} + +inline nsIntPoint +nsPoint::ToNearestPixels(nscoord aAppUnitsPerPixel) const +{ + return ScaleToNearestPixels(1.0f, 1.0f, aAppUnitsPerPixel); +} + +inline nsPoint +nsPoint::ScaleToOtherAppUnits(int32_t aFromAPP, int32_t aToAPP) const +{ + if (aFromAPP != aToAPP) { + nsPoint point; + point.x = NSToCoordRound(NSCoordScale(x, aFromAPP, aToAPP)); + point.y = NSToCoordRound(NSCoordScale(y, aFromAPP, aToAPP)); + return point; + } + return *this; +} + +inline nsPoint +nsPoint::RemoveResolution(const float resolution) const { + if (resolution != 1.0f) { + nsPoint point; + point.x = NSToCoordRound(NSCoordToFloat(x) / resolution); + point.y = NSToCoordRound(NSCoordToFloat(y) / resolution); + return point; + } + return *this; +} + +inline nsPoint +nsPoint::ApplyResolution(const float resolution) const { + if (resolution != 1.0f) { + nsPoint point; + point.x = NSToCoordRound(NSCoordToFloat(x) * resolution); + point.y = NSToCoordRound(NSCoordToFloat(y) * resolution); + return point; + } + return *this; +} + + +inline nsPoint +ToAppUnits(const nsIntPoint& aPoint, nscoord aAppUnitsPerPixel) +{ + return nsPoint(NSIntPixelsToAppUnits(aPoint.x, aAppUnitsPerPixel), + NSIntPixelsToAppUnits(aPoint.y, aAppUnitsPerPixel)); +} +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMargin.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseMargin.h" 1 +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseMargin.h" +namespace mozilla { + + + + +struct Sides final { + Sides() : mBits(0) {} + explicit Sides(SideBits aSideBits) + { + do { } while (0); + mBits = aSideBits; + } + bool IsEmpty() const { return mBits == 0; } + bool Top() const { return (mBits & eSideBitsTop) != 0; } + bool Right() const { return (mBits & eSideBitsRight) != 0; } + bool Bottom() const { return (mBits & eSideBitsBottom) != 0; } + bool Left() const { return (mBits & eSideBitsLeft) != 0; } + bool Contains(SideBits aSideBits) const + { + do { } while (0); + return (mBits & aSideBits) == aSideBits; + } + Sides operator|(Sides aOther) const + { + return Sides(SideBits(mBits | aOther.mBits)); + } + Sides operator|(SideBits aSideBits) const + { + return *this | Sides(aSideBits); + } + Sides& operator|=(Sides aOther) + { + mBits |= aOther.mBits; + return *this; + } + Sides& operator|=(SideBits aSideBits) + { + return *this |= Sides(aSideBits); + } + bool operator==(Sides aOther) const + { + return mBits == aOther.mBits; + } + bool operator!=(Sides aOther) const + { + return !(*this == aOther); + } + +private: + uint8_t mBits; +}; + +namespace gfx { + + + + + +template +struct BaseMargin { + typedef mozilla::Side SideT; + + + + T top, right, bottom, left; + + + BaseMargin() : top(0), right(0), bottom(0), left(0) {} + BaseMargin(T aTop, T aRight, T aBottom, T aLeft) : + top(aTop), right(aRight), bottom(aBottom), left(aLeft) {} + + void SizeTo(T aTop, T aRight, T aBottom, T aLeft) + { + top = aTop; right = aRight; bottom = aBottom; left = aLeft; + } + + T LeftRight() const { return left + right; } + T TopBottom() const { return top + bottom; } + + T& Side(SideT aSide) { + + return *(&top + int(aSide)); + } + T Side(SideT aSide) const { + + return *(&top + int(aSide)); + } + + void ApplySkipSides(Sides aSkipSides) + { + if (aSkipSides.Top()) { + top = 0; + } + if (aSkipSides.Right()) { + right = 0; + } + if (aSkipSides.Bottom()) { + bottom = 0; + } + if (aSkipSides.Left()) { + left = 0; + } + } + + + + bool operator==(const Sub& aMargin) const { + return top == aMargin.top && right == aMargin.right && + bottom == aMargin.bottom && left == aMargin.left; + } + bool operator!=(const Sub& aMargin) const { + return !(*this == aMargin); + } + Sub operator+(const Sub& aMargin) const { + return Sub(top + aMargin.top, right + aMargin.right, + bottom + aMargin.bottom, left + aMargin.left); + } + Sub operator-(const Sub& aMargin) const { + return Sub(top - aMargin.top, right - aMargin.right, + bottom - aMargin.bottom, left - aMargin.left); + } + Sub& operator+=(const Sub& aMargin) { + top += aMargin.top; + right += aMargin.right; + bottom += aMargin.bottom; + left += aMargin.left; + return *static_cast(this); + } + + friend std::ostream& operator<<(std::ostream& aStream, + const BaseMargin& aMargin) { + return aStream << '(' << aMargin.top << ',' << aMargin.right << ',' + << aMargin.bottom << ',' << aMargin.left << ')'; + } +}; + +} +} +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMargin.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Rect.h" 1 + + + + + + + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseRect.h" 1 +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseRect.h" +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3 +# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseRect.h" 2 + + + + + + + +namespace mozilla { +namespace gfx { +# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseRect.h" +template +struct BaseRect { + T x, y, width, height; + + + BaseRect() : x(0), y(0), width(0), height(0) {} + BaseRect(const Point& aOrigin, const SizeT &aSize) : + x(aOrigin.x), y(aOrigin.y), width(aSize.width), height(aSize.height) + { + } + BaseRect(T aX, T aY, T aWidth, T aHeight) : + x(aX), y(aY), width(aWidth), height(aHeight) + { + } + + + + bool IsEmpty() const { return height <= 0 || width <= 0; } + void SetEmpty() { width = height = 0; } + + + bool IsFinite() const + { + typedef typename mozilla::Conditional::value, float, double>::Type FloatType; + return (mozilla::IsFinite(FloatType(x)) && + mozilla::IsFinite(FloatType(y)) && + mozilla::IsFinite(FloatType(width)) && + mozilla::IsFinite(FloatType(height))); + } + + + + + bool Contains(const Sub& aRect) const + { + return aRect.IsEmpty() || + (x <= aRect.x && aRect.XMost() <= XMost() && + y <= aRect.y && aRect.YMost() <= YMost()); + } + + + + bool Contains(T aX, T aY) const + { + return x <= aX && aX < XMost() && + y <= aY && aY < YMost(); + } + + + + bool Contains(const Point& aPoint) const { return Contains(aPoint.x, aPoint.y); } + + + + + bool Intersects(const Sub& aRect) const + { + return !IsEmpty() && !aRect.IsEmpty() && + x < aRect.XMost() && aRect.x < XMost() && + y < aRect.YMost() && aRect.y < YMost(); + } + + + + + __attribute__ ((warn_unused_result)) Sub Intersect(const Sub& aRect) const + { + Sub result; + result.x = std::max(x, aRect.x); + result.y = std::max(y, aRect.y); + result.width = std::min(x - result.x + width, aRect.x - result.x + aRect.width); + result.height = std::min(y - result.y + height, aRect.y - result.y + aRect.height); + if (result.width < 0 || result.height < 0) { + result.SizeTo(0, 0); + } + return result; + } + + + + + + + bool IntersectRect(const Sub& aRect1, const Sub& aRect2) + { + *static_cast(this) = aRect1.Intersect(aRect2); + return !IsEmpty(); + } + + + + + + + + __attribute__ ((warn_unused_result)) Sub Union(const Sub& aRect) const + { + if (IsEmpty()) { + return aRect; + } else if (aRect.IsEmpty()) { + return *static_cast(this); + } else { + return UnionEdges(aRect); + } + } + + + + + + __attribute__ ((warn_unused_result)) Sub UnionEdges(const Sub& aRect) const + { + Sub result; + result.x = std::min(x, aRect.x); + result.y = std::min(y, aRect.y); + result.width = std::max(XMost(), aRect.XMost()) - result.x; + result.height = std::max(YMost(), aRect.YMost()) - result.y; + return result; + } + + + + + + + void UnionRect(const Sub& aRect1, const Sub& aRect2) + { + *static_cast(this) = aRect1.Union(aRect2); + } + + + + + + + void UnionRectEdges(const Sub& aRect1, const Sub& aRect2) + { + *static_cast(this) = aRect1.UnionEdges(aRect2); + } + + + void ExpandToEnclose(const Point& aPoint) + { + if (aPoint.x < x) { + width = XMost() - aPoint.x; + x = aPoint.x; + } else if (aPoint.x > XMost()) { + width = aPoint.x - x; + } + if (aPoint.y < y) { + height = YMost() - aPoint.y; + y = aPoint.y; + } else if (aPoint.y > YMost()) { + height = aPoint.y - y; + } + } + + void SetRect(T aX, T aY, T aWidth, T aHeight) + { + x = aX; y = aY; width = aWidth; height = aHeight; + } + void SetRect(const Point& aPt, const SizeT& aSize) + { + SetRect(aPt.x, aPt.y, aSize.width, aSize.height); + } + void MoveTo(T aX, T aY) { x = aX; y = aY; } + void MoveTo(const Point& aPoint) { x = aPoint.x; y = aPoint.y; } + void MoveBy(T aDx, T aDy) { x += aDx; y += aDy; } + void MoveBy(const Point& aPoint) { x += aPoint.x; y += aPoint.y; } + void SizeTo(T aWidth, T aHeight) { width = aWidth; height = aHeight; } + void SizeTo(const SizeT& aSize) { width = aSize.width; height = aSize.height; } + + void Inflate(T aD) { Inflate(aD, aD); } + void Inflate(T aDx, T aDy) + { + x -= aDx; + y -= aDy; + width += 2 * aDx; + height += 2 * aDy; + } + void Inflate(const MarginT& aMargin) + { + x -= aMargin.left; + y -= aMargin.top; + width += aMargin.LeftRight(); + height += aMargin.TopBottom(); + } + void Inflate(const SizeT& aSize) { Inflate(aSize.width, aSize.height); } + + void Deflate(T aD) { Deflate(aD, aD); } + void Deflate(T aDx, T aDy) + { + x += aDx; + y += aDy; + width = std::max(T(0), width - 2 * aDx); + height = std::max(T(0), height - 2 * aDy); + } + void Deflate(const MarginT& aMargin) + { + x += aMargin.left; + y += aMargin.top; + width = std::max(T(0), width - aMargin.LeftRight()); + height = std::max(T(0), height - aMargin.TopBottom()); + } + void Deflate(const SizeT& aSize) { Deflate(aSize.width, aSize.height); } + + + + + + bool IsEqualEdges(const Sub& aRect) const + { + return x == aRect.x && y == aRect.y && + width == aRect.width && height == aRect.height; + } + + + bool IsEqualInterior(const Sub& aRect) const + { + return IsEqualEdges(aRect) || (IsEmpty() && aRect.IsEmpty()); + } + + friend Sub operator+(Sub aSub, const Point& aPoint) + { + aSub += aPoint; + return aSub; + } + friend Sub operator-(Sub aSub, const Point& aPoint) + { + aSub -= aPoint; + return aSub; + } + friend Sub operator+(Sub aSub, const SizeT& aSize) + { + aSub += aSize; + return aSub; + } + friend Sub operator-(Sub aSub, const SizeT& aSize) + { + aSub -= aSize; + return aSub; + } + Sub& operator+=(const Point& aPoint) + { + MoveBy(aPoint); + return *static_cast(this); + } + Sub& operator-=(const Point& aPoint) + { + MoveBy(-aPoint); + return *static_cast(this); + } + Sub& operator+=(const SizeT& aSize) + { + width += aSize.width; + height += aSize.height; + return *static_cast(this); + } + Sub& operator-=(const SizeT& aSize) + { + width -= aSize.width; + height -= aSize.height; + return *static_cast(this); + } + + MarginT operator-(const Sub& aRect) const + { + return MarginT(aRect.y - y, + XMost() - aRect.XMost(), + YMost() - aRect.YMost(), + aRect.x - x); + } + + + Point TopLeft() const { return Point(x, y); } + Point TopRight() const { return Point(XMost(), y); } + Point BottomLeft() const { return Point(x, YMost()); } + Point BottomRight() const { return Point(XMost(), YMost()); } + Point AtCorner(Corner aCorner) const { + switch (aCorner) { + case eCornerTopLeft: return TopLeft(); + case eCornerTopRight: return TopRight(); + case eCornerBottomRight: return BottomRight(); + case eCornerBottomLeft: return BottomLeft(); + } + do { AnnotateMozCrashReason("MOZ_CRASH(" "GFX: Incomplete switch" ")"); do { *((volatile int*) __null) = 329; ::abort(); } while (0); } while (0); + } + Point CCWCorner(mozilla::Side side) const { + switch (side) { + case eSideTop: return TopLeft(); + case eSideRight: return TopRight(); + case eSideBottom: return BottomRight(); + case eSideLeft: return BottomLeft(); + } + do { AnnotateMozCrashReason("MOZ_CRASH(" "GFX: Incomplete switch" ")"); do { *((volatile int*) __null) = 338; ::abort(); } while (0); } while (0); + } + Point CWCorner(mozilla::Side side) const { + switch (side) { + case eSideTop: return TopRight(); + case eSideRight: return BottomRight(); + case eSideBottom: return BottomLeft(); + case eSideLeft: return TopLeft(); + } + do { AnnotateMozCrashReason("MOZ_CRASH(" "GFX: Incomplete switch" ")"); do { *((volatile int*) __null) = 347; ::abort(); } while (0); } while (0); + } + Point Center() const { return Point(x, y) + Point(width, height)/2; } + SizeT Size() const { return SizeT(width, height); } + + T Area() const { return width * height; } + + + T X() const { return x; } + T Y() const { return y; } + T Width() const { return width; } + T Height() const { return height; } + T XMost() const { return x + width; } + T YMost() const { return y + height; } + + + T Edge(mozilla::Side aSide) const + { + switch (aSide) { + case eSideTop: return Y(); + case eSideRight: return XMost(); + case eSideBottom: return YMost(); + case eSideLeft: return X(); + } + do { AnnotateMozCrashReason("MOZ_CRASH(" "GFX: Incomplete switch" ")"); do { *((volatile int*) __null) = 371; ::abort(); } while (0); } while (0); + } + + + void SetLeftEdge(T aX) { + do { } while (0); + width = XMost() - aX; + x = aX; + } + void SetRightEdge(T aXMost) { + do { } while (0); + width = aXMost - x; + } + void SetTopEdge(T aY) { + do { } while (0); + height = YMost() - aY; + y = aY; + } + void SetBottomEdge(T aYMost) { + do { } while (0); + height = aYMost - y; + } +# 405 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseRect.h" + void Round() + { + T x0 = static_cast(floor(T(X()) + 0.5)); + T y0 = static_cast(floor(T(Y()) + 0.5)); + T x1 = static_cast(floor(T(XMost()) + 0.5)); + T y1 = static_cast(floor(T(YMost()) + 0.5)); + + x = x0; + y = y0; + + width = x1 - x0; + height = y1 - y0; + } + + + + void RoundIn() + { + T x0 = static_cast(ceil(T(X()))); + T y0 = static_cast(ceil(T(Y()))); + T x1 = static_cast(floor(T(XMost()))); + T y1 = static_cast(floor(T(YMost()))); + + x = x0; + y = y0; + + width = x1 - x0; + height = y1 - y0; + } + + + + void RoundOut() + { + T x0 = static_cast(floor(T(X()))); + T y0 = static_cast(floor(T(Y()))); + T x1 = static_cast(ceil(T(XMost()))); + T y1 = static_cast(ceil(T(YMost()))); + + x = x0; + y = y0; + + width = x1 - x0; + height = y1 - y0; + } + + + void Scale(T aScale) { Scale(aScale, aScale); } + + void Scale(T aXScale, T aYScale) + { + T right = XMost() * aXScale; + T bottom = YMost() * aYScale; + x = x * aXScale; + y = y * aYScale; + width = right - x; + height = bottom - y; + } + + + + void ScaleRoundOut(double aScale) { ScaleRoundOut(aScale, aScale); } + + + + + void ScaleRoundOut(double aXScale, double aYScale) + { + T right = static_cast(ceil(double(XMost()) * aXScale)); + T bottom = static_cast(ceil(double(YMost()) * aYScale)); + x = static_cast(floor(double(x) * aXScale)); + y = static_cast(floor(double(y) * aYScale)); + width = right - x; + height = bottom - y; + } + + + void ScaleRoundIn(double aScale) { ScaleRoundIn(aScale, aScale); } + + + + void ScaleRoundIn(double aXScale, double aYScale) + { + T right = static_cast(floor(double(XMost()) * aXScale)); + T bottom = static_cast(floor(double(YMost()) * aYScale)); + x = static_cast(ceil(double(x) * aXScale)); + y = static_cast(ceil(double(y) * aYScale)); + width = std::max(0, right - x); + height = std::max(0, bottom - y); + } + + + + void ScaleInverseRoundOut(double aScale) { ScaleInverseRoundOut(aScale, aScale); } + + + + + void ScaleInverseRoundOut(double aXScale, double aYScale) + { + T right = static_cast(ceil(double(XMost()) / aXScale)); + T bottom = static_cast(ceil(double(YMost()) / aYScale)); + x = static_cast(floor(double(x) / aXScale)); + y = static_cast(floor(double(y) / aYScale)); + width = right - x; + height = bottom - y; + } + + + void ScaleInverseRoundIn(double aScale) { ScaleInverseRoundIn(aScale, aScale); } + + + + void ScaleInverseRoundIn(double aXScale, double aYScale) + { + T right = static_cast(floor(double(XMost()) / aXScale)); + T bottom = static_cast(floor(double(YMost()) / aYScale)); + x = static_cast(ceil(double(x) / aXScale)); + y = static_cast(ceil(double(y) / aYScale)); + width = std::max(0, right - x); + height = std::max(0, bottom - y); + } + + + + + + __attribute__ ((warn_unused_result)) Point ClampPoint(const Point& aPoint) const + { + return Point(std::max(x, std::min(XMost(), aPoint.x)), + std::max(y, std::min(YMost(), aPoint.y))); + } + + + + + + + __attribute__ ((warn_unused_result)) Sub MoveInsideAndClamp(const Sub& aRect) const + { + Sub rect(std::max(aRect.x, x), + std::max(aRect.y, y), + std::min(aRect.width, width), + std::min(aRect.height, height)); + rect.x = std::min(rect.XMost(), aRect.XMost()) - rect.width; + rect.y = std::min(rect.YMost(), aRect.YMost()) - rect.height; + return rect; + } + + + + + + + + static Sub MaxIntRect() + { + return Sub( + static_cast(-std::numeric_limits::max() * 0.5), + static_cast(-std::numeric_limits::max() * 0.5), + static_cast(std::numeric_limits::max()), + static_cast(std::numeric_limits::max()) + ); + }; + + friend std::ostream& operator<<(std::ostream& stream, + const BaseRect& aRect) { + return stream << '(' << aRect.x << ',' << aRect.y << ',' + << aRect.width << ',' << aRect.height << ')'; + } + +private: + + + bool operator==(const Sub& aRect) const { return false; } + bool operator!=(const Sub& aRect) const { return false; } +}; + +} +} +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Rect.h" 2 + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/NumericTools.h" 1 + + + + + + + + +namespace mozilla { + + + + + + +inline int32_t +RoundDownToMultiple(int32_t x, int32_t aMultiplier) +{ + + + int mod = x % aMultiplier; + if (x > 0) { + return x - mod; + } + return mod ? x - aMultiplier - mod : x; +} + + + + +inline int32_t +RoundUpToMultiple(int32_t x, int32_t aMultiplier) +{ + int mod = x % aMultiplier; + if (x > 0) { + return mod ? x + aMultiplier - mod : x; + } + return x - mod; +} + +} +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Rect.h" 2 + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Tools.h" 1 + + + + + + + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h" 1 +# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h" +namespace mozilla { + +template class CheckedInt; + +namespace detail { +# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h" +struct UnsupportedType {}; + +template +struct IsSupportedPass2 +{ + static const bool value = false; +}; + +template +struct IsSupported +{ + static const bool value = IsSupportedPass2::value; +}; + +template<> +struct IsSupported +{ static const bool value = true; }; + +template<> +struct IsSupported +{ static const bool value = true; }; + +template<> +struct IsSupported +{ static const bool value = true; }; + +template<> +struct IsSupported +{ static const bool value = true; }; + +template<> +struct IsSupported +{ static const bool value = true; }; + +template<> +struct IsSupported +{ static const bool value = true; }; + +template<> +struct IsSupported +{ static const bool value = true; }; + +template<> +struct IsSupported +{ static const bool value = true; }; + + +template<> +struct IsSupportedPass2 +{ static const bool value = true; }; + +template<> +struct IsSupportedPass2 +{ static const bool value = true; }; + +template<> +struct IsSupportedPass2 +{ static const bool value = true; }; + +template<> +struct IsSupportedPass2 +{ static const bool value = true; }; + +template<> +struct IsSupportedPass2 +{ static const bool value = true; }; + +template<> +struct IsSupportedPass2 +{ static const bool value = true; }; + +template<> +struct IsSupportedPass2 +{ static const bool value = true; }; + +template<> +struct IsSupportedPass2 +{ static const bool value = true; }; + +template<> +struct IsSupportedPass2 +{ static const bool value = true; }; + +template<> +struct IsSupportedPass2 +{ static const bool value = true; }; + +template<> +struct IsSupportedPass2 +{ static const bool value = true; }; + + + + + + + +template +struct TwiceBiggerType +{ + typedef typename detail::StdintTypeForSizeAndSignedness< + sizeof(IntegerType) * 2, + IsSigned::value + >::Type Type; +}; + +template +struct TwiceBiggerType +{ + typedef UnsupportedType Type; +}; + +template +inline bool +HasSignBit(T aX) +{ + + + + + return bool(typename MakeUnsigned::Type(aX) >> + PositionOfSignBit::value); +} + + + +template +inline T +BinaryComplement(T aX) +{ + return ~aX; +} + +template::value, + bool IsUSigned = IsSigned::value> +struct DoesRangeContainRange +{ +}; + +template +struct DoesRangeContainRange +{ + static const bool value = sizeof(T) >= sizeof(U); +}; + +template +struct DoesRangeContainRange +{ + static const bool value = sizeof(T) > sizeof(U); +}; + +template +struct DoesRangeContainRange +{ + static const bool value = false; +}; + +template::value, + bool IsUSigned = IsSigned::value, + bool DoesTRangeContainURange = DoesRangeContainRange::value> +struct IsInRangeImpl {}; + +template +struct IsInRangeImpl +{ + static bool constexpr run(U) + { + return true; + } +}; + +template +struct IsInRangeImpl +{ + static bool constexpr run(U aX) + { + return aX <= MaxValue::value && aX >= MinValue::value; + } +}; + +template +struct IsInRangeImpl +{ + static bool constexpr run(U aX) + { + return aX <= MaxValue::value; + } +}; + +template +struct IsInRangeImpl +{ + static bool constexpr run(U aX) + { + return sizeof(T) > sizeof(U) || aX <= U(MaxValue::value); + } +}; + +template +struct IsInRangeImpl +{ + static bool constexpr run(U aX) + { + return sizeof(T) >= sizeof(U) + ? aX >= 0 + : aX >= 0 && aX <= U(MaxValue::value); + } +}; + +template +inline constexpr bool +IsInRange(U aX) +{ + return IsInRangeImpl::run(aX); +} + +template +inline bool +IsAddValid(T aX, T aY) +{ + + + + + + + typename MakeUnsigned::Type ux = aX; + typename MakeUnsigned::Type uy = aY; + typename MakeUnsigned::Type result = ux + uy; + return IsSigned::value + ? HasSignBit(BinaryComplement(T((result ^ aX) & (result ^ aY)))) + : BinaryComplement(aX) >= aY; +} + +template +inline bool +IsSubValid(T aX, T aY) +{ + + + + typename MakeUnsigned::Type ux = aX; + typename MakeUnsigned::Type uy = aY; + typename MakeUnsigned::Type result = ux - uy; + + return IsSigned::value + ? HasSignBit(BinaryComplement(T((result ^ aX) & (aX ^ aY)))) + : aX >= aY; +} + +template::value, + bool TwiceBiggerTypeIsSupported = + IsSupported::Type>::value> +struct IsMulValidImpl {}; + +template +struct IsMulValidImpl +{ + static bool run(T aX, T aY) + { + typedef typename TwiceBiggerType::Type TwiceBiggerType; + TwiceBiggerType product = TwiceBiggerType(aX) * TwiceBiggerType(aY); + return IsInRange(product); + } +}; + +template +struct IsMulValidImpl +{ + static bool run(T aX, T aY) + { + const T max = MaxValue::value; + const T min = MinValue::value; + + if (aX == 0 || aY == 0) { + return true; + } + if (aX > 0) { + return aY > 0 + ? aX <= max / aY + : aY >= min / aX; + } + + + return aY > 0 + ? aX >= min / aY + : aY >= max / aX; + } +}; + +template +struct IsMulValidImpl +{ + static bool run(T aX, T aY) + { + return aY == 0 || aX <= MaxValue::value / aY; + } +}; + +template +inline bool +IsMulValid(T aX, T aY) +{ + return IsMulValidImpl::run(aX, aY); +} + +template +inline bool +IsDivValid(T aX, T aY) +{ + + + return aY != 0 && + !(IsSigned::value && aX == MinValue::value && aY == T(-1)); +} + +template::value> +struct IsModValidImpl; + +template +inline bool +IsModValid(T aX, T aY) +{ + return IsModValidImpl::run(aX, aY); +} +# 376 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h" +template +struct IsModValidImpl +{ + static inline bool run(T aX, T aY) + { + return aY >= 1; + } +}; + +template +struct IsModValidImpl +{ + static inline bool run(T aX, T aY) + { + if (aX < 0) { + return false; + } + return aY >= 1; + } +}; + +template::value> +struct NegateImpl; + +template +struct NegateImpl +{ + static CheckedInt negate(const CheckedInt& aVal) + { + + + return CheckedInt(0, aVal.isValid() && aVal.mValue == 0); + } +}; + +template +struct NegateImpl +{ + static CheckedInt negate(const CheckedInt& aVal) + { + + + if (!aVal.isValid() || aVal.mValue == MinValue::value) { + return CheckedInt(aVal.mValue, false); + } + return CheckedInt(-aVal.mValue, true); + } +}; + +} +# 499 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h" +template +class CheckedInt +{ +protected: + T mValue; + bool mIsValid; + + template + CheckedInt(U aValue, bool aIsValid) : mValue(aValue), mIsValid(aIsValid) + { + static_assert(detail::IsSupported::value && + detail::IsSupported::value, + "This type is not supported by CheckedInt"); + } + + friend struct detail::NegateImpl; + +public: +# 528 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h" + template + constexpr CheckedInt(U aValue) + : mValue(T(aValue)), + mIsValid(detail::IsInRange(aValue)) + { + static_assert(detail::IsSupported::value && + detail::IsSupported::value, + "This type is not supported by CheckedInt"); + } + + template + friend class CheckedInt; + + template + CheckedInt toChecked() const + { + CheckedInt ret(mValue); + ret.mIsValid = ret.mIsValid && mIsValid; + return ret; + } + + + constexpr CheckedInt() : mValue(0), mIsValid(true) + { + static_assert(detail::IsSupported::value, + "This type is not supported by CheckedInt"); + } + + + T value() const + { + do { } while (0); + return mValue; + } + + + + + + + bool isValid() const + { + return mIsValid; + } + + template + friend CheckedInt operator +(const CheckedInt& aLhs, + const CheckedInt& aRhs); + template + CheckedInt& operator +=(U aRhs); + CheckedInt& operator +=(const CheckedInt& aRhs); + + template + friend CheckedInt operator -(const CheckedInt& aLhs, + const CheckedInt& aRhs); + template + CheckedInt& operator -=(U aRhs); + CheckedInt& operator -=(const CheckedInt& aRhs); + + template + friend CheckedInt operator *(const CheckedInt& aLhs, + const CheckedInt& aRhs); + template + CheckedInt& operator *=(U aRhs); + CheckedInt& operator *=(const CheckedInt& aRhs); + + template + friend CheckedInt operator /(const CheckedInt& aLhs, + const CheckedInt& aRhs); + template + CheckedInt& operator /=(U aRhs); + CheckedInt& operator /=(const CheckedInt& aRhs); + + template + friend CheckedInt operator %(const CheckedInt& aLhs, + const CheckedInt& aRhs); + template + CheckedInt& operator %=(U aRhs); + CheckedInt& operator %=(const CheckedInt& aRhs); + + CheckedInt operator -() const + { + return detail::NegateImpl::negate(*this); + } +# 631 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h" + bool operator ==(const CheckedInt& aOther) const + { + return mIsValid && aOther.mIsValid && mValue == aOther.mValue; + } + + + CheckedInt& operator++() + { + *this += 1; + return *this; + } + + + CheckedInt operator++(int) + { + CheckedInt tmp = *this; + *this += 1; + return tmp; + } + + + CheckedInt& operator--() + { + *this -= 1; + return *this; + } + + + CheckedInt operator--(int) + { + CheckedInt tmp = *this; + *this -= 1; + return tmp; + } + +private: + + + + + template bool operator !=(U aOther) const = delete; + template bool operator < (U aOther) const = delete; + template bool operator <=(U aOther) const = delete; + template bool operator > (U aOther) const = delete; + template bool operator >=(U aOther) const = delete; +}; +# 690 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h" +template inline CheckedInt operator +(const CheckedInt& aLhs, const CheckedInt& aRhs) { if (!detail::IsAddValid(aLhs.mValue, aRhs.mValue)) { return CheckedInt(0, false); } return CheckedInt(aLhs.mValue + aRhs.mValue, aLhs.mIsValid && aRhs.mIsValid); } +template inline CheckedInt operator -(const CheckedInt& aLhs, const CheckedInt& aRhs) { if (!detail::IsSubValid(aLhs.mValue, aRhs.mValue)) { return CheckedInt(0, false); } return CheckedInt(aLhs.mValue - aRhs.mValue, aLhs.mIsValid && aRhs.mIsValid); } +template inline CheckedInt operator *(const CheckedInt& aLhs, const CheckedInt& aRhs) { if (!detail::IsMulValid(aLhs.mValue, aRhs.mValue)) { return CheckedInt(0, false); } return CheckedInt(aLhs.mValue * aRhs.mValue, aLhs.mIsValid && aRhs.mIsValid); } +template inline CheckedInt operator /(const CheckedInt& aLhs, const CheckedInt& aRhs) { if (!detail::IsDivValid(aLhs.mValue, aRhs.mValue)) { return CheckedInt(0, false); } return CheckedInt(aLhs.mValue / aRhs.mValue, aLhs.mIsValid && aRhs.mIsValid); } +template inline CheckedInt operator %(const CheckedInt& aLhs, const CheckedInt& aRhs) { if (!detail::IsModValid(aLhs.mValue, aRhs.mValue)) { return CheckedInt(0, false); } return CheckedInt(aLhs.mValue % aRhs.mValue, aLhs.mIsValid && aRhs.mIsValid); } +# 704 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h" +namespace detail { + +template +struct CastToCheckedIntImpl +{ + typedef CheckedInt ReturnType; + static CheckedInt run(U aU) { return aU; } +}; + +template +struct CastToCheckedIntImpl > +{ + typedef const CheckedInt& ReturnType; + static const CheckedInt& run(const CheckedInt& aU) { return aU; } +}; + +} + +template +inline typename detail::CastToCheckedIntImpl::ReturnType +castToCheckedInt(U aU) +{ + static_assert(detail::IsSupported::value && + detail::IsSupported::value, + "This type is not supported by CheckedInt"); + return detail::CastToCheckedIntImpl::run(aU); +} +# 757 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h" +template template CheckedInt& CheckedInt::operator +=(U aRhs) { *this = *this + castToCheckedInt(aRhs); return *this; } template CheckedInt& CheckedInt::operator +=(const CheckedInt& aRhs) { *this = *this + aRhs; return *this; } template inline CheckedInt operator +(const CheckedInt& aLhs, U aRhs) { return aLhs + castToCheckedInt(aRhs); } template inline CheckedInt operator +(U aLhs, const CheckedInt& aRhs) { return castToCheckedInt(aLhs) + aRhs; } +template template CheckedInt& CheckedInt::operator *=(U aRhs) { *this = *this * castToCheckedInt(aRhs); return *this; } template CheckedInt& CheckedInt::operator *=(const CheckedInt& aRhs) { *this = *this * aRhs; return *this; } template inline CheckedInt operator *(const CheckedInt& aLhs, U aRhs) { return aLhs * castToCheckedInt(aRhs); } template inline CheckedInt operator *(U aLhs, const CheckedInt& aRhs) { return castToCheckedInt(aLhs) * aRhs; } +template template CheckedInt& CheckedInt::operator -=(U aRhs) { *this = *this - castToCheckedInt(aRhs); return *this; } template CheckedInt& CheckedInt::operator -=(const CheckedInt& aRhs) { *this = *this - aRhs; return *this; } template inline CheckedInt operator -(const CheckedInt& aLhs, U aRhs) { return aLhs - castToCheckedInt(aRhs); } template inline CheckedInt operator -(U aLhs, const CheckedInt& aRhs) { return castToCheckedInt(aLhs) - aRhs; } +template template CheckedInt& CheckedInt::operator /=(U aRhs) { *this = *this / castToCheckedInt(aRhs); return *this; } template CheckedInt& CheckedInt::operator /=(const CheckedInt& aRhs) { *this = *this / aRhs; return *this; } template inline CheckedInt operator /(const CheckedInt& aLhs, U aRhs) { return aLhs / castToCheckedInt(aRhs); } template inline CheckedInt operator /(U aLhs, const CheckedInt& aRhs) { return castToCheckedInt(aLhs) / aRhs; } +template template CheckedInt& CheckedInt::operator %=(U aRhs) { *this = *this % castToCheckedInt(aRhs); return *this; } template CheckedInt& CheckedInt::operator %=(const CheckedInt& aRhs) { *this = *this % aRhs; return *this; } template inline CheckedInt operator %(const CheckedInt& aLhs, U aRhs) { return aLhs % castToCheckedInt(aRhs); } template inline CheckedInt operator %(U aLhs, const CheckedInt& aRhs) { return castToCheckedInt(aLhs) % aRhs; } + + + +template +inline bool +operator ==(const CheckedInt& aLhs, U aRhs) +{ + return aLhs == castToCheckedInt(aRhs); +} + +template +inline bool +operator ==(U aLhs, const CheckedInt& aRhs) +{ + return castToCheckedInt(aLhs) == aRhs; +} + + +typedef CheckedInt CheckedInt8; +typedef CheckedInt CheckedUint8; +typedef CheckedInt CheckedInt16; +typedef CheckedInt CheckedUint16; +typedef CheckedInt CheckedInt32; +typedef CheckedInt CheckedUint32; +typedef CheckedInt CheckedInt64; +typedef CheckedInt CheckedUint64; + +} +# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Tools.h" 2 + + + + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/math.h" 1 3 +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Tools.h" 2 + +namespace mozilla { +namespace gfx { + +static inline bool +IsOperatorBoundByMask(CompositionOp aOp) { + switch (aOp) { + case CompositionOp::OP_IN: + case CompositionOp::OP_OUT: + case CompositionOp::OP_DEST_IN: + case CompositionOp::OP_DEST_ATOP: + case CompositionOp::OP_SOURCE: + return false; + default: + return true; + } +} + +template +struct ClassStorage +{ + char bytes[sizeof(T)]; + + const T *addr() const { return (const T *)bytes; } + T *addr() { return (T *)(void *)bytes; } +}; + +static inline bool +FuzzyEqual(Float aA, Float aB, Float aErr) +{ + if ((aA + aErr >= aB) && (aA - aErr <= aB)) { + return true; + } + return false; +} + +static inline void +NudgeToInteger(float *aVal) +{ + float r = floorf(*aVal + 0.5f); + + + + + + if (FuzzyEqual(r, *aVal, r == 0.0f ? 1e-6f : fabs(r*1e-6f))) { + *aVal = r; + } +} + +static inline void +NudgeToInteger(float *aVal, float aErr) +{ + float r = floorf(*aVal + 0.5f); + if (FuzzyEqual(r, *aVal, aErr)) { + *aVal = r; + } +} + +static inline Float +Distance(Point aA, Point aB) +{ + return hypotf(aB.x - aA.x, aB.y - aA.y); +} + +static inline int +BytesPerPixel(SurfaceFormat aFormat) +{ + switch (aFormat) { + case SurfaceFormat::A8: + return 1; + case SurfaceFormat::R5G6B5_UINT16: + return 2; + case SurfaceFormat::R8G8B8: + case SurfaceFormat::B8G8R8: + return 3; + case SurfaceFormat::HSV: + case SurfaceFormat::Lab: + return 3 * sizeof(float); + case SurfaceFormat::Depth: + return sizeof(uint16_t); + default: + return 4; + } +} + +static inline bool +IsOpaqueFormat(SurfaceFormat aFormat) { + switch (aFormat) { + case SurfaceFormat::B8G8R8X8: + case SurfaceFormat::R8G8B8X8: + case SurfaceFormat::X8R8G8B8: + case SurfaceFormat::YUV: + case SurfaceFormat::NV12: + case SurfaceFormat::YUV422: + case SurfaceFormat::R5G6B5_UINT16: + return true; + default: + return false; + } +} + +template +struct AlignedArray +{ + typedef T value_type; + + AlignedArray() + : mPtr(nullptr) + , mStorage(nullptr) + { + } + + explicit __attribute__((always_inline)) inline AlignedArray(size_t aCount, bool aZero = false) + : mStorage(nullptr) + , mCount(0) + { + Realloc(aCount, aZero); + } + + __attribute__((always_inline)) inline ~AlignedArray() + { + Dealloc(); + } + + void Dealloc() + { + + + + + static_assert(mozilla::IsPod::value, + "Destructors must be invoked for this type"); +# 158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Tools.h" + free(mStorage); + mStorage = nullptr; + mPtr = nullptr; + } + + __attribute__((always_inline)) inline void Realloc(size_t aCount, bool aZero = false) + { + free(mStorage); + CheckedInt32 storageByteCount = + CheckedInt32(sizeof(T)) * aCount + (alignment - 1); + if (!storageByteCount.isValid()) { + mStorage = nullptr; + mPtr = nullptr; + mCount = 0; + return; + } + + + if (aZero) { + + + mStorage = static_cast(calloc(1, storageByteCount.value())); + } else { + mStorage = static_cast(malloc(storageByteCount.value())); + } + if (!mStorage) { + mStorage = nullptr; + mPtr = nullptr; + mCount = 0; + return; + } + if (uintptr_t(mStorage) % alignment) { + + mPtr = (T*)(uintptr_t(mStorage) + alignment - (uintptr_t(mStorage) % alignment)); + } else { + mPtr = (T*)(mStorage); + } + + + + + mPtr = new (mPtr) T[aCount]; + mCount = aCount; + } + + void Swap(AlignedArray& aOther) + { + mozilla::Swap(mPtr, aOther.mPtr); + mozilla::Swap(mStorage, aOther.mStorage); + mozilla::Swap(mCount, aOther.mCount); + } + + __attribute__((always_inline)) inline operator T*() + { + return mPtr; + } + + T *mPtr; + +private: + uint8_t *mStorage; + size_t mCount; +}; +# 230 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Tools.h" +template +int32_t GetAlignedStride(int32_t aWidth, int32_t aBytesPerPixel) +{ + static_assert(alignment > 0 && (alignment & (alignment-1)) == 0, + "This implementation currently require power-of-two alignment"); + const int32_t mask = alignment - 1; + CheckedInt32 stride = CheckedInt32(aWidth) * CheckedInt32(aBytesPerPixel) + CheckedInt32(mask); + if (stride.isValid()) { + return stride.value() & ~mask; + } + return 0; +} + +} +} +# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Rect.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h" 1 +# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h" +namespace mozilla { + +struct Nothing { }; +# 85 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h" +template +class Maybe +{ + alignas(T) unsigned char mStorage[sizeof(T)]; + char mIsSome; + + + + void* data() { return mStorage; } + const void* data() const { return mStorage; } + +public: + using ValueType = T; + + Maybe() : mIsSome(false) { } + ~Maybe() { reset(); } + + Maybe(Nothing) : mIsSome(false) { } + + Maybe(const Maybe& aOther) + : mIsSome(false) + { + if (aOther.mIsSome) { + emplace(*aOther); + } + } + + + + + template::value>::type> + + Maybe(const Maybe& aOther) + : mIsSome(false) + { + if (aOther.isSome()) { + emplace(*aOther); + } + } + + Maybe(Maybe&& aOther) + : mIsSome(false) + { + if (aOther.mIsSome) { + emplace(Move(*aOther)); + aOther.reset(); + } + } + + + + + template::value>::type> + + Maybe(Maybe&& aOther) + : mIsSome(false) + { + if (aOther.isSome()) { + emplace(Move(*aOther)); + aOther.reset(); + } + } + + Maybe& operator=(const Maybe& aOther) + { + if (&aOther != this) { + if (aOther.mIsSome) { + if (mIsSome) { + ref() = aOther.ref(); + } else { + emplace(*aOther); + } + } else { + reset(); + } + } + return *this; + } + + template::value>::type> + Maybe& operator=(const Maybe& aOther) + { + if (aOther.isSome()) { + if (mIsSome) { + ref() = aOther.ref(); + } else { + emplace(*aOther); + } + } else { + reset(); + } + return *this; + } + + Maybe& operator=(Maybe&& aOther) + { + do { } while (0); + + if (aOther.mIsSome) { + if (mIsSome) { + ref() = Move(aOther.ref()); + } else { + emplace(Move(*aOther)); + } + aOther.reset(); + } else { + reset(); + } + + return *this; + } + + template::value>::type> + Maybe& operator=(Maybe&& aOther) + { + if (aOther.isSome()) { + if (mIsSome) { + ref() = Move(aOther.ref()); + } else { + emplace(Move(*aOther)); + } + aOther.reset(); + } else { + reset(); + } + + return *this; + } + + + explicit operator bool() const { return isSome(); } + bool isSome() const { return mIsSome; } + bool isNothing() const { return !mIsSome; } + + + T value() const + { + do { } while (0); + return ref(); + } + + + + + + template + T valueOr(V&& aDefault) const + { + if (isSome()) { + return ref(); + } + return Forward(aDefault); + } + + + + + + template + T valueOrFrom(F&& aFunc) const + { + if (isSome()) { + return ref(); + } + return aFunc(); + } + + + T* ptr() + { + do { } while (0); + return &ref(); + } + + const T* ptr() const + { + do { } while (0); + return &ref(); + } + + + + + + T* ptrOr(T* aDefault) + { + if (isSome()) { + return ptr(); + } + return aDefault; + } + + const T* ptrOr(const T* aDefault) const + { + if (isSome()) { + return ptr(); + } + return aDefault; + } + + + + + + template + T* ptrOrFrom(F&& aFunc) + { + if (isSome()) { + return ptr(); + } + return aFunc(); + } + + template + const T* ptrOrFrom(F&& aFunc) const + { + if (isSome()) { + return ptr(); + } + return aFunc(); + } + + T* operator->() + { + do { } while (0); + return ptr(); + } + + const T* operator->() const + { + do { } while (0); + return ptr(); + } + + + T& ref() + { + do { } while (0); + return *static_cast(data()); + } + + const T& ref() const + { + do { } while (0); + return *static_cast(data()); + } + + + + + + T& refOr(T& aDefault) + { + if (isSome()) { + return ref(); + } + return aDefault; + } + + const T& refOr(const T& aDefault) const + { + if (isSome()) { + return ref(); + } + return aDefault; + } + + + + + + template + T& refOrFrom(F&& aFunc) + { + if (isSome()) { + return ref(); + } + return aFunc(); + } + + template + const T& refOrFrom(F&& aFunc) const + { + if (isSome()) { + return ref(); + } + return aFunc(); + } + + T& operator*() + { + do { } while (0); + return ref(); + } + + const T& operator*() const + { + do { } while (0); + return ref(); + } + + + + template + Maybe& apply(Func aFunc) + { + if (isSome()) { + aFunc(ref()); + } + return *this; + } + + template + const Maybe& apply(Func aFunc) const + { + if (isSome()) { + aFunc(ref()); + } + return *this; + } + + + + + + template + auto map(Func aFunc) -> Maybe>().ref()))> + { + using ReturnType = decltype(aFunc(ref())); + if (isSome()) { + Maybe val; + val.emplace(aFunc(ref())); + return val; + } + return Maybe(); + } + + template + auto map(Func aFunc) const -> Maybe>().ref()))> + { + using ReturnType = decltype(aFunc(ref())); + if (isSome()) { + Maybe val; + val.emplace(aFunc(ref())); + return val; + } + return Maybe(); + } + + + void reset() + { + if (isSome()) { + ref().T::~T(); + mIsSome = false; + } + } + + + + + + template + void emplace(Args&&... aArgs) + { + do { } while (0); + ::new (KnownNotNull, data()) T(Forward(aArgs)...); + mIsSome = true; + } + + friend std::ostream& + operator<<(std::ostream& aStream, const Maybe& aMaybe) + { + if (aMaybe) { + aStream << aMaybe.ref(); + } else { + aStream << ""; + } + return aStream; + } +}; +# 485 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h" +template::type>::type> +Maybe +Some(T&& aValue) +{ + Maybe value; + value.emplace(Forward(aValue)); + return value; +} + +template +Maybe::Type>::Type> +ToMaybe(T* aPtr) +{ + if (aPtr) { + return Some(*aPtr); + } + return Nothing(); +} + + + + + + +template bool +operator==(const Maybe& aLHS, const Maybe& aRHS) +{ + if (aLHS.isNothing() != aRHS.isNothing()) { + return false; + } + return aLHS.isNothing() || *aLHS == *aRHS; +} + +template bool +operator!=(const Maybe& aLHS, const Maybe& aRHS) +{ + return !(aLHS == aRHS); +} + + + + + +template bool +operator==(const Maybe& aLHS, const Nothing& aRHS) +{ + return aLHS.isNothing(); +} + +template bool +operator!=(const Maybe& aLHS, const Nothing& aRHS) +{ + return !(aLHS == aRHS); +} + +template bool +operator==(const Nothing& aLHS, const Maybe& aRHS) +{ + return aRHS.isNothing(); +} + +template bool +operator!=(const Nothing& aLHS, const Maybe& aRHS) +{ + return !(aLHS == aRHS); +} + + + + + +template bool +operator<(const Maybe& aLHS, const Maybe& aRHS) +{ + if (aLHS.isNothing()) { + return aRHS.isSome(); + } + if (aRHS.isNothing()) { + return false; + } + return *aLHS < *aRHS; +} + +template bool +operator>(const Maybe& aLHS, const Maybe& aRHS) +{ + return !(aLHS < aRHS || aLHS == aRHS); +} + +template bool +operator<=(const Maybe& aLHS, const Maybe& aRHS) +{ + return aLHS < aRHS || aLHS == aRHS; +} + +template bool +operator>=(const Maybe& aLHS, const Maybe& aRHS) +{ + return !(aLHS < aRHS); +} + +} +# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Rect.h" 2 + +# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3 +# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3 +# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Rect.h" 2 + +namespace mozilla { + +template struct IsPixel; + +namespace gfx { + +template struct RectTyped; + +template +struct IntMarginTyped: + public BaseMargin >, + public units { + static_assert(IsPixel::value, + "'units' must be a coordinate system tag"); + + typedef BaseMargin > Super; + + IntMarginTyped() : Super() {} + IntMarginTyped(int32_t aTop, int32_t aRight, int32_t aBottom, int32_t aLeft) : + Super(aTop, aRight, aBottom, aLeft) {} + + + + + static IntMarginTyped FromUnknownMargin(const IntMarginTyped& aMargin) { + return IntMarginTyped(aMargin.top, aMargin.right, + aMargin.bottom, aMargin.left); + } + + IntMarginTyped ToUnknownMargin() const { + return IntMarginTyped(this->top, this->right, + this->bottom, this->left); + } +}; +typedef IntMarginTyped IntMargin; + +template +struct MarginTyped: + public BaseMargin >, + public units { + static_assert(IsPixel::value, + "'units' must be a coordinate system tag"); + + typedef BaseMargin > Super; + + MarginTyped() : Super() {} + MarginTyped(F aTop, F aRight, F aBottom, F aLeft) : + Super(aTop, aRight, aBottom, aLeft) {} + explicit MarginTyped(const IntMarginTyped& aMargin) : + Super(F(aMargin.top), F(aMargin.right), + F(aMargin.bottom), F(aMargin.left)) {} +}; +typedef MarginTyped Margin; +typedef MarginTyped MarginDouble; + +template +IntMarginTyped RoundedToInt(const MarginTyped& aMargin) +{ + return IntMarginTyped(int32_t(floorf(aMargin.top + 0.5f)), + int32_t(floorf(aMargin.right + 0.5f)), + int32_t(floorf(aMargin.bottom + 0.5f)), + int32_t(floorf(aMargin.left + 0.5f))); +} + +template +struct IntRectTyped : + public BaseRect, IntPointTyped, IntSizeTyped, IntMarginTyped >, + public units { + static_assert(IsPixel::value, + "'units' must be a coordinate system tag"); + + typedef BaseRect, IntPointTyped, IntSizeTyped, IntMarginTyped > Super; + typedef IntRectTyped Self; + typedef IntParam ToInt; + + IntRectTyped() : Super() {} + IntRectTyped(const IntPointTyped& aPos, const IntSizeTyped& aSize) : + Super(aPos, aSize) {} + + IntRectTyped(ToInt aX, ToInt aY, ToInt aWidth, ToInt aHeight) : + Super(aX.value, aY.value, aWidth.value, aHeight.value) {} + + static IntRectTyped RoundIn(float aX, float aY, float aW, float aH) { + return IntRectTyped::RoundIn(RectTyped(aX, aY, aW, aH)); + } + + static IntRectTyped RoundOut(float aX, float aY, float aW, float aH) { + return IntRectTyped::RoundOut(RectTyped(aX, aY, aW, aH)); + } + + static IntRectTyped Round(float aX, float aY, float aW, float aH) { + return IntRectTyped::Round(RectTyped(aX, aY, aW, aH)); + } + + static IntRectTyped Truncate(float aX, float aY, float aW, float aH) { + return IntRectTyped(IntPointTyped::Truncate(aX, aY), + IntSizeTyped::Truncate(aW, aH)); + } + + static IntRectTyped RoundIn(const RectTyped& aRect) { + auto tmp(aRect); + tmp.RoundIn(); + return IntRectTyped(int32_t(tmp.x), int32_t(tmp.y), + int32_t(tmp.width), int32_t(tmp.height)); + } + + static IntRectTyped RoundOut(const RectTyped& aRect) { + auto tmp(aRect); + tmp.RoundOut(); + return IntRectTyped(int32_t(tmp.x), int32_t(tmp.y), + int32_t(tmp.width), int32_t(tmp.height)); + } + + static IntRectTyped Round(const RectTyped& aRect) { + auto tmp(aRect); + tmp.Round(); + return IntRectTyped(int32_t(tmp.x), int32_t(tmp.y), + int32_t(tmp.width), int32_t(tmp.height)); + } + + static IntRectTyped Truncate(const RectTyped& aRect) { + return IntRectTyped::Truncate(aRect.x, aRect.y, aRect.width, aRect.height); + } + + + void Round() {} + void RoundIn() {} + void RoundOut() {} + + + + + static IntRectTyped FromUnknownRect(const IntRectTyped& rect) { + return IntRectTyped(rect.x, rect.y, rect.width, rect.height); + } + + IntRectTyped ToUnknownRect() const { + return IntRectTyped(this->x, this->y, this->width, this->height); + } + + bool Overflows() const { + CheckedInt xMost = this->x; + xMost += this->width; + CheckedInt yMost = this->y; + yMost += this->height; + return !xMost.isValid() || !yMost.isValid(); + } + + + + + __attribute__ ((warn_unused_result)) Maybe SafeUnion(const Self& aRect) const + { + if (this->IsEmpty()) { + return aRect.Overflows() ? Nothing() : Some(aRect); + } else if (aRect.IsEmpty()) { + return Some(*static_cast(this)); + } else { + return this->SafeUnionEdges(aRect); + } + } + + + + __attribute__ ((warn_unused_result)) Maybe SafeUnionEdges(const Self& aRect) const + { + if (this->Overflows() || aRect.Overflows()) { + return Nothing(); + } + + + CheckedInt newX = std::min(this->x, aRect.x); + CheckedInt newY = std::min(this->y, aRect.y); + CheckedInt newXMost = std::max(this->XMost(), aRect.XMost()); + CheckedInt newYMost = std::max(this->YMost(), aRect.YMost()); + CheckedInt newW = newXMost - newX; + CheckedInt newH = newYMost - newY; + if (!newW.isValid() || !newH.isValid()) { + return Nothing(); + } + return Some(Self(newX.value(), newY.value(), newW.value(), newH.value())); + } + + + bool operator==(const IntRectTyped& aRect) const + { + return IntRectTyped::IsEqualEdges(aRect); + } + + void InflateToMultiple(const IntSizeTyped& aTileSize) + { + if (this->IsEmpty()) { + return; + } + + int32_t yMost = this->YMost(); + int32_t xMost = this->XMost(); + + this->x = mozilla::RoundDownToMultiple(this->x, aTileSize.width); + this->y = mozilla::RoundDownToMultiple(this->y, aTileSize.height); + xMost = mozilla::RoundUpToMultiple(xMost, aTileSize.width); + yMost = mozilla::RoundUpToMultiple(yMost, aTileSize.height); + + this->width = xMost - this->x; + this->height = yMost - this->y; + } + +}; +typedef IntRectTyped IntRect; + +template +struct RectTyped : + public BaseRect, PointTyped, SizeTyped, MarginTyped >, + public units { + static_assert(IsPixel::value, + "'units' must be a coordinate system tag"); + + typedef BaseRect, PointTyped, SizeTyped, MarginTyped > Super; + + RectTyped() : Super() {} + RectTyped(const PointTyped& aPos, const SizeTyped& aSize) : + Super(aPos, aSize) {} + RectTyped(F _x, F _y, F _width, F _height) : + Super(_x, _y, _width, _height) {} + explicit RectTyped(const IntRectTyped& rect) : + Super(F(rect.x), F(rect.y), + F(rect.width), F(rect.height)) {} + + void NudgeToIntegers() + { + NudgeToInteger(&(this->x)); + NudgeToInteger(&(this->y)); + NudgeToInteger(&(this->width)); + NudgeToInteger(&(this->height)); + } + + bool ToIntRect(IntRectTyped *aOut) const + { + *aOut = IntRectTyped(int32_t(this->X()), int32_t(this->Y()), + int32_t(this->Width()), int32_t(this->Height())); + return RectTyped(F(aOut->x), F(aOut->y), + F(aOut->width), F(aOut->height)) + .IsEqualEdges(*this); + } + + + + + static RectTyped FromUnknownRect(const RectTyped& rect) { + return RectTyped(rect.x, rect.y, rect.width, rect.height); + } + + RectTyped ToUnknownRect() const { + return RectTyped(this->x, this->y, this->width, this->height); + } + + + bool operator==(const RectTyped& aRect) const + { + return RectTyped::IsEqualEdges(aRect); + } +}; +typedef RectTyped Rect; +typedef RectTyped RectDouble; + +template +IntRectTyped RoundedToInt(const RectTyped& aRect) +{ + RectTyped copy(aRect); + copy.Round(); + return IntRectTyped(int32_t(copy.x), + int32_t(copy.y), + int32_t(copy.width), + int32_t(copy.height)); +} + +template +IntRectTyped RoundedIn(const RectTyped& aRect) +{ + return IntRectTyped::RoundIn(aRect); +} + +template +IntRectTyped RoundedOut(const RectTyped& aRect) +{ + return IntRectTyped::RoundOut(aRect); +} + +template +IntRectTyped TruncatedToInt(const RectTyped& aRect) { + return IntRectTyped::Truncate(aRect); +} + +template +RectTyped IntRectToRect(const IntRectTyped& aRect) +{ + return RectTyped(aRect.x, aRect.y, aRect.width, aRect.height); +} + + +template +Maybe +IntersectMaybeRects(const Maybe& a, const Maybe& b) +{ + if (!a) { + return b; + } else if (!b) { + return a; + } else { + return Some(a->Intersect(*b)); + } +} + +} +} +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMargin.h" 2 + +struct nsMargin : public mozilla::gfx::BaseMargin { + typedef mozilla::gfx::BaseMargin Super; + + + nsMargin() : Super() {} + nsMargin(const nsMargin& aMargin) : Super(aMargin) {} + nsMargin(nscoord aTop, nscoord aRight, nscoord aBottom, nscoord aLeft) + : Super(aTop, aRight, aBottom, aLeft) {} +}; + +typedef mozilla::gfx::IntMargin nsIntMargin; +# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h" 2 + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/SVGAttrValueWrapper.h" 1 +# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/SVGAttrValueWrapper.h" +class nsSVGAngle; +class nsSVGIntegerPair; +class nsSVGLength2; +class nsSVGNumberPair; +class nsSVGViewBox; + +namespace mozilla { +class SVGLengthList; +class SVGNumberList; +class SVGPathData; +class SVGPointList; +class SVGAnimatedPreserveAspectRatio; +class SVGStringList; +class SVGTransformList; +} + +namespace mozilla { + +class SVGAttrValueWrapper +{ +public: + static void ToString(const nsSVGAngle* aAngle, nsAString& aResult); + static void ToString(const nsSVGIntegerPair* aIntegerPair, + nsAString& aResult); + static void ToString(const nsSVGLength2* aLength, nsAString& aResult); + static void ToString(const mozilla::SVGLengthList* aLengthList, + nsAString& aResult); + static void ToString(const mozilla::SVGNumberList* aNumberList, + nsAString& aResult); + static void ToString(const nsSVGNumberPair* aNumberPair, nsAString& aResult); + static void ToString(const mozilla::SVGPathData* aPathData, + nsAString& aResult); + static void ToString(const mozilla::SVGPointList* aPointList, + nsAString& aResult); + static void ToString( + const mozilla::SVGAnimatedPreserveAspectRatio* aPreserveAspectRatio, + nsAString& aResult); + static void ToString(const mozilla::SVGStringList* aStringList, + nsAString& aResult); + static void ToString(const mozilla::SVGTransformList* aTransformList, + nsAString& aResult); + static void ToString(const nsSVGViewBox* aViewBox, nsAString& aResult); +}; + +} +# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h" 2 + + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingDeclarations.h" 1 +# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingDeclarations.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h" 1 +# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h" +namespace JS { class Value; } +# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h" +enum JSValueType +{ + JSVAL_TYPE_DOUBLE = 0x00, + JSVAL_TYPE_INT32 = 0x01, + JSVAL_TYPE_UNDEFINED = 0x02, + JSVAL_TYPE_NULL = 0x03, + JSVAL_TYPE_BOOLEAN = 0x04, + JSVAL_TYPE_MAGIC = 0x05, + JSVAL_TYPE_STRING = 0x06, + JSVAL_TYPE_SYMBOL = 0x07, + JSVAL_TYPE_PRIVATE_GCTHING = 0x08, + JSVAL_TYPE_OBJECT = 0x0c, + + + JSVAL_TYPE_UNKNOWN = 0x20, + JSVAL_TYPE_MISSING = 0x21 +} __attribute__((packed)); + +static_assert(sizeof(JSValueType) == 1, + "compiler typed enum support is apparently buggy"); +# 90 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h" +enum JSValueTag +{ + JSVAL_TAG_MAX_DOUBLE = 0x1FFF0, + JSVAL_TAG_INT32 = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_INT32, + JSVAL_TAG_UNDEFINED = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_UNDEFINED, + JSVAL_TAG_NULL = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_NULL, + JSVAL_TAG_BOOLEAN = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_BOOLEAN, + JSVAL_TAG_MAGIC = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_MAGIC, + JSVAL_TAG_STRING = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_STRING, + JSVAL_TAG_SYMBOL = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_SYMBOL, + JSVAL_TAG_PRIVATE_GCTHING = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_PRIVATE_GCTHING, + JSVAL_TAG_OBJECT = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_OBJECT +} __attribute__((packed)); + +static_assert(sizeof(JSValueTag) == sizeof(uint32_t), + "compiler typed enum support is apparently buggy"); + +enum JSValueShiftedTag +{ + JSVAL_SHIFTED_TAG_MAX_DOUBLE = ((((uint64_t)JSVAL_TAG_MAX_DOUBLE) << 47) | 0xFFFFFFFF), + JSVAL_SHIFTED_TAG_INT32 = (((uint64_t)JSVAL_TAG_INT32) << 47), + JSVAL_SHIFTED_TAG_UNDEFINED = (((uint64_t)JSVAL_TAG_UNDEFINED) << 47), + JSVAL_SHIFTED_TAG_NULL = (((uint64_t)JSVAL_TAG_NULL) << 47), + JSVAL_SHIFTED_TAG_BOOLEAN = (((uint64_t)JSVAL_TAG_BOOLEAN) << 47), + JSVAL_SHIFTED_TAG_MAGIC = (((uint64_t)JSVAL_TAG_MAGIC) << 47), + JSVAL_SHIFTED_TAG_STRING = (((uint64_t)JSVAL_TAG_STRING) << 47), + JSVAL_SHIFTED_TAG_SYMBOL = (((uint64_t)JSVAL_TAG_SYMBOL) << 47), + JSVAL_SHIFTED_TAG_PRIVATE_GCTHING = (((uint64_t)JSVAL_TAG_PRIVATE_GCTHING) << 47), + JSVAL_SHIFTED_TAG_OBJECT = (((uint64_t)JSVAL_TAG_OBJECT) << 47) +} __attribute__((packed)); + +static_assert(sizeof(JSValueShiftedTag) == sizeof(uint64_t), + "compiler typed enum support is apparently buggy"); +# 161 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h" +typedef enum JSWhyMagic +{ + + JS_ELEMENTS_HOLE, + + + JS_NO_ITER_VALUE, + + + JS_GENERATOR_CLOSING, + + + JS_NO_CONSTANT, + + + JS_THIS_POISON, + + + JS_ARG_POISON, + + + JS_SERIALIZE_NO_NODE, + + + JS_LAZY_ARGUMENTS, + + + JS_OPTIMIZED_ARGUMENTS, + + + JS_IS_CONSTRUCTING, + + + JS_BLOCK_NEEDS_CLONE, + + + JS_HASH_KEY_EMPTY, + + + JS_ION_ERROR, + + + JS_ION_BAILOUT, + + + JS_OPTIMIZED_OUT, + + + JS_UNINITIALIZED_LEXICAL, + + + JS_GENERIC_MAGIC, + + JS_WHY_MAGIC_COUNT +} JSWhyMagic; + +namespace JS { + +static inline constexpr JS::Value UndefinedValue(); +static inline JS::Value PoisonedObjectValue(JSObject* obj); + +namespace detail { + +constexpr int CanonicalizedNaNSignBit = 0; +constexpr uint64_t CanonicalizedNaNSignificand = 0x8000000000000ULL; + +constexpr uint64_t CanonicalizedNaNBits = + mozilla::SpecificNaNBits::value; + +} + + + + + + + +static __attribute__((always_inline)) inline double +GenericNaN() +{ + return mozilla::SpecificNaN(detail::CanonicalizedNaNSignBit, + detail::CanonicalizedNaNSignificand); +} + + + + + +static inline double +CanonicalizeNaN(double d) +{ + if ((__builtin_expect(!!(mozilla::IsNaN(d)), 0))) + return GenericNaN(); + return d; +} +# 293 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h" +class alignas(8) Value +{ + public: + + + + using PayloadType = uint64_t; + + + + + + + Value() = default; + Value(const Value& v) = default; + + + + + + template + static bool isNumberRepresentable(const T t) { + return T(double(t)) == t; + } + + + + void setNull() { + data.asBits = bitsFromTagAndPayload(JSVAL_TAG_NULL, 0); + } + + void setUndefined() { + data.asBits = bitsFromTagAndPayload(JSVAL_TAG_UNDEFINED, 0); + } + + void setInt32(int32_t i) { + data.asBits = bitsFromTagAndPayload(JSVAL_TAG_INT32, uint32_t(i)); + } + + int32_t& getInt32Ref() { + do { } while (0); + return data.s.payload.i32; + } + + void setDouble(double d) { + + + data = layout(d); + do { } while (0); + } + + void setNaN() { + setDouble(GenericNaN()); + } + + double& getDoubleRef() { + do { } while (0); + return data.asDouble; + } + + void setString(JSString* str) { + do { } while (0); + data.asBits = bitsFromTagAndPayload(JSVAL_TAG_STRING, PayloadType(str)); + } + + void setSymbol(JS::Symbol* sym) { + do { } while (0); + data.asBits = bitsFromTagAndPayload(JSVAL_TAG_SYMBOL, PayloadType(sym)); + } + + void setObject(JSObject& obj) { + do { } while (0); + + + + + + do { } while (0); + + setObjectNoCheck(&obj); + } + + private: + void setObjectNoCheck(JSObject* obj) { + data.asBits = bitsFromTagAndPayload(JSVAL_TAG_OBJECT, PayloadType(obj)); + } + + friend inline Value PoisonedObjectValue(JSObject* obj); + + public: + void setBoolean(bool b) { + data.asBits = bitsFromTagAndPayload(JSVAL_TAG_BOOLEAN, uint32_t(b)); + } + + void setMagic(JSWhyMagic why) { + data.asBits = bitsFromTagAndPayload(JSVAL_TAG_MAGIC, uint32_t(why)); + } + + void setMagicUint32(uint32_t payload) { + data.asBits = bitsFromTagAndPayload(JSVAL_TAG_MAGIC, payload); + } + + bool setNumber(uint32_t ui) { + if (ui > ((int32_t)0x7fffffff)) { + setDouble((double)ui); + return false; + } else { + setInt32((int32_t)ui); + return true; + } + } + + bool setNumber(double d) { + int32_t i; + if (mozilla::NumberIsInt32(d, &i)) { + setInt32(i); + return true; + } + + setDouble(d); + return false; + } + + void setObjectOrNull(JSObject* arg) { + if (arg) + setObject(*arg); + else + setNull(); + } + + void swap(Value& rhs) { + uint64_t tmp = rhs.data.asBits; + rhs.data.asBits = data.asBits; + data.asBits = tmp; + } + + private: + JSValueTag toTag() const { + + + + return JSValueTag(data.asBits >> 47); + + } + + public: +# 449 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h" + const void* bitsAsPunboxPointer() const { + return reinterpret_cast(data.asBits); + } +# 463 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h" + bool isUndefined() const { + + + + return data.asBits == JSVAL_SHIFTED_TAG_UNDEFINED; + + } + + bool isNull() const { + + + + return data.asBits == JSVAL_SHIFTED_TAG_NULL; + + } + + bool isNullOrUndefined() const { + return isNull() || isUndefined(); + } + + bool isInt32() const { + return toTag() == JSVAL_TAG_INT32; + } + + bool isInt32(int32_t i32) const { + return data.asBits == bitsFromTagAndPayload(JSVAL_TAG_INT32, uint32_t(i32)); + } + + bool isDouble() const { + + + + return (data.asBits | mozilla::DoubleTypeTraits::kSignBit) <= JSVAL_SHIFTED_TAG_MAX_DOUBLE; + + } + + bool isNumber() const { + + + + + return data.asBits < JSVAL_SHIFTED_TAG_UNDEFINED; + + } + + bool isString() const { + return toTag() == JSVAL_TAG_STRING; + } + + bool isSymbol() const { + return toTag() == JSVAL_TAG_SYMBOL; + } + + bool isObject() const { + + + + do { } while (0); + return data.asBits >= JSVAL_SHIFTED_TAG_OBJECT; + + } + + bool isPrimitive() const { + + + + return data.asBits < JSVAL_SHIFTED_TAG_OBJECT; + + } + + bool isObjectOrNull() const { + return isObject() || isNull(); + } + + bool isGCThing() const { + + + + + return data.asBits >= JSVAL_SHIFTED_TAG_STRING; + + } + + bool isBoolean() const { + return toTag() == JSVAL_TAG_BOOLEAN; + } + + bool isTrue() const { + return data.asBits == bitsFromTagAndPayload(JSVAL_TAG_BOOLEAN, uint32_t(true)); + } + + bool isFalse() const { + return data.asBits == bitsFromTagAndPayload(JSVAL_TAG_BOOLEAN, uint32_t(false)); + } + + bool isMagic() const { + return toTag() == JSVAL_TAG_MAGIC; + } + + bool isMagic(JSWhyMagic why) const { + do { } while (0); + return isMagic(); + } + + JS::TraceKind traceKind() const { + do { } while (0); + static_assert((JSVAL_TAG_STRING & 0x03) == size_t(JS::TraceKind::String), + "Value type tags must correspond with JS::TraceKinds."); + static_assert((JSVAL_TAG_SYMBOL & 0x03) == size_t(JS::TraceKind::Symbol), + "Value type tags must correspond with JS::TraceKinds."); + static_assert((JSVAL_TAG_OBJECT & 0x03) == size_t(JS::TraceKind::Object), + "Value type tags must correspond with JS::TraceKinds."); + if ((__builtin_expect(!!(isPrivateGCThing()), 0))) + return JS::GCThingTraceKind(toGCThing()); + return JS::TraceKind(toTag() & 0x03); + } + + JSWhyMagic whyMagic() const { + do { } while (0); + return data.s.payload.why; + } + + uint32_t magicUint32() const { + do { } while (0); + return data.s.payload.u32; + } + + + + bool operator==(const Value& rhs) const { + return data.asBits == rhs.data.asBits; + } + + bool operator!=(const Value& rhs) const { + return data.asBits != rhs.data.asBits; + } + + friend inline bool SameType(const Value& lhs, const Value& rhs); + + + + int32_t toInt32() const { + do { } while (0); + + + + return int32_t(data.asBits); + + } + + double toDouble() const { + do { } while (0); + return data.asDouble; + } + + double toNumber() const { + do { } while (0); + return isDouble() ? toDouble() : double(toInt32()); + } + + JSString* toString() const { + do { } while (0); + + + + return reinterpret_cast(data.asBits & 0x00007FFFFFFFFFFFLL); + + } + + JS::Symbol* toSymbol() const { + do { } while (0); + + + + return reinterpret_cast(data.asBits & 0x00007FFFFFFFFFFFLL); + + } + + JSObject& toObject() const { + do { } while (0); + + + + return *toObjectOrNull(); + + } + + JSObject* toObjectOrNull() const { + do { } while (0); + + + + uint64_t ptrBits = data.asBits & 0x00007FFFFFFFFFFFLL; + do { } while (0); + return reinterpret_cast(ptrBits); + + } + + js::gc::Cell* toGCThing() const { + do { } while (0); + + + + uint64_t ptrBits = data.asBits & 0x00007FFFFFFFFFFFLL; + do { } while (0); + return reinterpret_cast(ptrBits); + + } + + GCCellPtr toGCCellPtr() const { + return GCCellPtr(toGCThing(), traceKind()); + } + + bool toBoolean() const { + do { } while (0); + + + + return bool(data.asBits & 0x00007FFFFFFFFFFFLL); + + } + + uint32_t payloadAsRawUint32() const { + do { } while (0); + return data.s.payload.u32; + } + + uint64_t asRawBits() const { + return data.asBits; + } + + JSValueType extractNonDoubleType() const { + uint32_t type = toTag() & 0xF; + do { } while (0); + return JSValueType(type); + } +# 709 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h" + void setPrivate(void* ptr) { + do { } while (0); + + + + + data.asBits = uintptr_t(ptr) >> 1; + + do { } while (0); + } + + void* toPrivate() const { + do { } while (0); + + + + do { } while (0); + return reinterpret_cast(data.asBits << 1); + + } + + void setPrivateUint32(uint32_t ui) { + do { } while (0); + setInt32(int32_t(ui)); + } + + uint32_t toPrivateUint32() const { + return uint32_t(toInt32()); + } +# 748 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h" + void setPrivateGCThing(js::gc::Cell* cell) { + do { } while (0); + + do { } while (0); + + do { } while (0); + + + do { } while (0); + + + + + + do { } while (0); + + data.asBits = bitsFromTagAndPayload(JSVAL_TAG_PRIVATE_GCTHING, PayloadType(cell)); + } + + bool isPrivateGCThing() const { + return toTag() == JSVAL_TAG_PRIVATE_GCTHING; + } + + const size_t* payloadWord() const { + + + + return &data.asWord; + + } + + const uintptr_t* payloadUIntPtr() const { + + + + return &data.asUIntPtr; + + } + + + + + + private: +# 822 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h" + union layout { + uint64_t asBits; + + + struct { + uint64_t payload47 : 47; + JSValueTag tag : 17; + } debugView; + + struct { + union { + int32_t i32; + uint32_t u32; + JSWhyMagic why; + } payload; + } s; + double asDouble; + void* asPtr; + size_t asWord; + uintptr_t asUIntPtr; + + layout() = default; + explicit constexpr layout(uint64_t bits) : asBits(bits) {} + explicit constexpr layout(double d) : asDouble(d) {} + } data; +# 902 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h" + private: + explicit constexpr Value(uint64_t asBits) : data(asBits) {} + explicit constexpr Value(double d) : data(d) {} + + void staticAssertions() { + static_assert(sizeof(JSValueType) == 1, "JS_STATIC_ASSERT"); + static_assert(sizeof(JSValueTag) == 4, "JS_STATIC_ASSERT"); + static_assert(sizeof(JSWhyMagic) <= 4, "JS_STATIC_ASSERT"); + static_assert(sizeof(Value) == 8, "JS_STATIC_ASSERT"); + } + + friend constexpr Value JS::UndefinedValue(); + + public: + static constexpr uint64_t + bitsFromTagAndPayload(JSValueTag tag, PayloadType payload) + { + + + + return (uint64_t(uint32_t(tag)) << 47) | payload; + + } + + static constexpr Value + fromTagAndPayload(JSValueTag tag, PayloadType payload) + { + return fromRawBits(bitsFromTagAndPayload(tag, payload)); + } + + static constexpr Value + fromRawBits(uint64_t asBits) { + return Value(asBits); + } + + static constexpr Value + fromInt32(int32_t i) { + return fromTagAndPayload(JSVAL_TAG_INT32, uint32_t(i)); + } + + static constexpr Value + fromDouble(double d) { + return Value(d); + } +} ; + +static_assert(sizeof(Value) == 8, "Value size must leave three tag bits, be a binary power, and is ubiquitously depended upon everywhere"); + +inline bool +IsOptimizedPlaceholderMagicValue(const Value& v) +{ + if (v.isMagic()) { + do { } while (0); + return true; + } + return false; +} + +static __attribute__((always_inline)) inline void +ExposeValueToActiveJS(const Value& v) +{ + if (v.isGCThing()) + js::gc::ExposeGCThingToActiveJS(GCCellPtr(v)); +} + + + +static inline Value +NullValue() +{ + Value v; + v.setNull(); + return v; +} + +static inline constexpr Value +UndefinedValue() +{ + return Value::fromTagAndPayload(JSVAL_TAG_UNDEFINED, 0); +} + +static inline constexpr Value +Int32Value(int32_t i32) +{ + return Value::fromInt32(i32); +} + +static inline Value +DoubleValue(double dbl) +{ + Value v; + v.setDouble(dbl); + return v; +} + +static inline Value +CanonicalizedDoubleValue(double d) +{ + return (__builtin_expect(!!(mozilla::IsNaN(d)), 0)) + ? Value::fromRawBits(detail::CanonicalizedNaNBits) + : Value::fromDouble(d); +} + +static inline bool +IsCanonicalized(double d) +{ + if (mozilla::IsInfinite(d) || mozilla::IsFinite(d)) + return true; + + uint64_t bits; + mozilla::BitwiseCast(d, &bits); + return (bits & ~mozilla::DoubleTypeTraits::kSignBit) == detail::CanonicalizedNaNBits; +} + +static inline Value +DoubleNaNValue() +{ + Value v; + v.setNaN(); + return v; +} + +static inline Value +Float32Value(float f) +{ + Value v; + v.setDouble(f); + return v; +} + +static inline Value +StringValue(JSString* str) +{ + Value v; + v.setString(str); + return v; +} + +static inline Value +SymbolValue(JS::Symbol* sym) +{ + Value v; + v.setSymbol(sym); + return v; +} + +static inline Value +BooleanValue(bool boo) +{ + Value v; + v.setBoolean(boo); + return v; +} + +static inline Value +TrueValue() +{ + Value v; + v.setBoolean(true); + return v; +} + +static inline Value +FalseValue() +{ + Value v; + v.setBoolean(false); + return v; +} + +static inline Value +ObjectValue(JSObject& obj) +{ + Value v; + v.setObject(obj); + return v; +} + +static inline Value +ObjectValueCrashOnTouch() +{ + Value v; + v.setObject(*reinterpret_cast(0x48)); + return v; +} + +static inline Value +MagicValue(JSWhyMagic why) +{ + Value v; + v.setMagic(why); + return v; +} + +static inline Value +MagicValueUint32(uint32_t payload) +{ + Value v; + v.setMagicUint32(payload); + return v; +} + +static inline Value +NumberValue(float f) +{ + Value v; + v.setNumber(f); + return v; +} + +static inline Value +NumberValue(double dbl) +{ + Value v; + v.setNumber(dbl); + return v; +} + +static inline Value +NumberValue(int8_t i) +{ + return Int32Value(i); +} + +static inline Value +NumberValue(uint8_t i) +{ + return Int32Value(i); +} + +static inline Value +NumberValue(int16_t i) +{ + return Int32Value(i); +} + +static inline Value +NumberValue(uint16_t i) +{ + return Int32Value(i); +} + +static inline Value +NumberValue(int32_t i) +{ + return Int32Value(i); +} + +static inline constexpr Value +NumberValue(uint32_t i) +{ + return i <= ((int32_t)0x7fffffff) + ? Int32Value(int32_t(i)) + : Value::fromDouble(double(i)); +} + +namespace detail { + +template +class MakeNumberValue +{ + public: + template + static inline Value create(const T t) + { + Value v; + if (((int32_t)0x80000000) <= t && t <= ((int32_t)0x7fffffff)) + v.setInt32(int32_t(t)); + else + v.setDouble(double(t)); + return v; + } +}; + +template <> +class MakeNumberValue +{ + public: + template + static inline Value create(const T t) + { + Value v; + if (t <= ((int32_t)0x7fffffff)) + v.setInt32(int32_t(t)); + else + v.setDouble(double(t)); + return v; + } +}; + +} + +template +static inline Value +NumberValue(const T t) +{ + do { } while (0); + return detail::MakeNumberValue::is_signed>::create(t); +} + +static inline Value +ObjectOrNullValue(JSObject* obj) +{ + Value v; + v.setObjectOrNull(obj); + return v; +} + +static inline Value +PrivateValue(void* ptr) +{ + Value v; + v.setPrivate(ptr); + return v; +} + +static inline Value +PrivateUint32Value(uint32_t ui) +{ + Value v; + v.setPrivateUint32(ui); + return v; +} + +static inline Value +PrivateGCThingValue(js::gc::Cell* cell) +{ + Value v; + v.setPrivateGCThing(cell); + return v; +} + +static inline Value +PoisonedObjectValue(JSObject* obj) +{ + Value v; + v.setObjectNoCheck(obj); + return v; +} + +inline bool +SameType(const Value& lhs, const Value& rhs) +{ + + + + + return (lhs.isDouble() && rhs.isDouble()) || + (((lhs.data.asBits ^ rhs.data.asBits) & 0xFFFF800000000000ULL) == 0); + +} + +} + + + +namespace JS { +void HeapValuePostBarrier(Value* valuep, const Value& prev, const Value& next); + +template <> +struct GCPolicy +{ + static Value initial() { return UndefinedValue(); } + static void trace(JSTracer* trc, Value* v, const char* name) { + js::UnsafeTraceManuallyBarrieredEdge(trc, v, name); + } + static bool isTenured(const Value& thing) { + return !thing.isGCThing() || !IsInsideNursery(thing.toGCThing()); + } +}; + +} + +namespace js { + +template <> +struct BarrierMethods +{ + static gc::Cell* asGCThingOrNull(const JS::Value& v) { + return v.isGCThing() ? v.toGCThing() : nullptr; + } + static void postBarrier(JS::Value* v, const JS::Value& prev, const JS::Value& next) { + JS::HeapValuePostBarrier(v, prev, next); + } + static void exposeToJS(const JS::Value& v) { + JS::ExposeValueToActiveJS(v); + } +}; + +template class MutableValueOperations; + + + + + + + +template +class WrappedPtrOperations +{ + const JS::Value& value() const { return static_cast(this)->get(); } + + public: + bool isUndefined() const { return value().isUndefined(); } + bool isNull() const { return value().isNull(); } + bool isBoolean() const { return value().isBoolean(); } + bool isTrue() const { return value().isTrue(); } + bool isFalse() const { return value().isFalse(); } + bool isNumber() const { return value().isNumber(); } + bool isInt32() const { return value().isInt32(); } + bool isInt32(int32_t i32) const { return value().isInt32(i32); } + bool isDouble() const { return value().isDouble(); } + bool isString() const { return value().isString(); } + bool isSymbol() const { return value().isSymbol(); } + bool isObject() const { return value().isObject(); } + bool isMagic() const { return value().isMagic(); } + bool isMagic(JSWhyMagic why) const { return value().isMagic(why); } + bool isGCThing() const { return value().isGCThing(); } + bool isPrimitive() const { return value().isPrimitive(); } + + bool isNullOrUndefined() const { return value().isNullOrUndefined(); } + bool isObjectOrNull() const { return value().isObjectOrNull(); } + + bool toBoolean() const { return value().toBoolean(); } + double toNumber() const { return value().toNumber(); } + int32_t toInt32() const { return value().toInt32(); } + double toDouble() const { return value().toDouble(); } + JSString* toString() const { return value().toString(); } + JS::Symbol* toSymbol() const { return value().toSymbol(); } + JSObject& toObject() const { return value().toObject(); } + JSObject* toObjectOrNull() const { return value().toObjectOrNull(); } + gc::Cell* toGCThing() const { return value().toGCThing(); } + JS::TraceKind traceKind() const { return value().traceKind(); } + void* toPrivate() const { return value().toPrivate(); } + uint32_t toPrivateUint32() const { return value().toPrivateUint32(); } + + uint64_t asRawBits() const { return value().asRawBits(); } + JSValueType extractNonDoubleType() const { return value().extractNonDoubleType(); } + + JSWhyMagic whyMagic() const { return value().whyMagic(); } + uint32_t magicUint32() const { return value().magicUint32(); } +}; + + + + + + + +template +class MutableWrappedPtrOperations : public WrappedPtrOperations +{ + JS::Value& value() { return static_cast(this)->get(); } + + public: + void setNull() { value().setNull(); } + void setUndefined() { value().setUndefined(); } + void setInt32(int32_t i) { value().setInt32(i); } + void setDouble(double d) { value().setDouble(d); } + void setNaN() { setDouble(JS::GenericNaN()); } + void setBoolean(bool b) { value().setBoolean(b); } + void setMagic(JSWhyMagic why) { value().setMagic(why); } + bool setNumber(uint32_t ui) { return value().setNumber(ui); } + bool setNumber(double d) { return value().setNumber(d); } + void setString(JSString* str) { this->value().setString(str); } + void setSymbol(JS::Symbol* sym) { this->value().setSymbol(sym); } + void setObject(JSObject& obj) { this->value().setObject(obj); } + void setObjectOrNull(JSObject* arg) { this->value().setObjectOrNull(arg); } + void setPrivate(void* ptr) { this->value().setPrivate(ptr); } + void setPrivateUint32(uint32_t ui) { this->value().setPrivateUint32(ui); } + void setPrivateGCThing(js::gc::Cell* cell) { this->value().setPrivateGCThing(cell); } +}; + + + + + +template +class HeapBase : public WrappedPtrOperations +{ + void setBarriered(const JS::Value& v) { + *static_cast*>(this) = v; + } + + public: + void setNull() { setBarriered(JS::NullValue()); } + void setUndefined() { setBarriered(JS::UndefinedValue()); } + void setInt32(int32_t i) { setBarriered(JS::Int32Value(i)); } + void setDouble(double d) { setBarriered(JS::DoubleValue(d)); } + void setNaN() { setDouble(JS::GenericNaN()); } + void setBoolean(bool b) { setBarriered(JS::BooleanValue(b)); } + void setMagic(JSWhyMagic why) { setBarriered(JS::MagicValue(why)); } + void setString(JSString* str) { setBarriered(JS::StringValue(str)); } + void setSymbol(JS::Symbol* sym) { setBarriered(JS::SymbolValue(sym)); } + void setObject(JSObject& obj) { setBarriered(JS::ObjectValue(obj)); } + void setPrivateGCThing(js::gc::Cell* cell) { setBarriered(JS::PrivateGCThingValue(cell)); } + + bool setNumber(uint32_t ui) { + if (ui > ((int32_t)0x7fffffff)) { + setDouble((double)ui); + return false; + } else { + setInt32((int32_t)ui); + return true; + } + } + + bool setNumber(double d) { + int32_t i; + if (mozilla::NumberIsInt32(d, &i)) { + setInt32(i); + return true; + } + + setDouble(d); + return false; + } + + void setObjectOrNull(JSObject* arg) { + if (arg) + setObject(*arg); + else + setNull(); + } +}; + + + + + +template +auto +DispatchTyped(F f, const JS::Value& val, Args&&... args) + -> decltype(f(static_cast(nullptr), mozilla::Forward(args)...)) +{ + if (val.isString()) + return f(val.toString(), mozilla::Forward(args)...); + if (val.isObject()) + return f(&val.toObject(), mozilla::Forward(args)...); + if (val.isSymbol()) + return f(val.toSymbol(), mozilla::Forward(args)...); + if ((__builtin_expect(!!(val.isPrivateGCThing()), 0))) + return DispatchTyped(f, val.toGCCellPtr(), mozilla::Forward(args)...); + do { } while (0); + return F::defaultValue(val); +} + +template struct VoidDefaultAdaptor { static void defaultValue(const S&) {} }; +template struct IdentityDefaultAdaptor { static S defaultValue(const S& v) {return v;} }; +template struct BoolDefaultAdaptor { static bool defaultValue(const S&) { return v; } }; + +} +# 1478 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h" +namespace JS { + +extern const HandleValue NullHandleValue; +extern const HandleValue UndefinedHandleValue; +extern const HandleValue TrueHandleValue; +extern const HandleValue FalseHandleValue; + +} +# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingDeclarations.h" 2 + + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RootedOwningNonNull.h" 1 +# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RootedOwningNonNull.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OwningNonNull.h" 1 +# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OwningNonNull.h" +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAutoPtr.h" 1 +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAutoPtr.h" +template +class nsAutoPtr +{ +private: + static_assert(!mozilla::IsScalar::value, "If you are using " + "nsAutoPtr to hold an array, use UniquePtr instead"); + + void** + begin_assignment() + { + assign(0); + return reinterpret_cast(&mRawPtr); + } + + void + assign(T* aNewPtr) + { + T* oldPtr = mRawPtr; + + if (aNewPtr && aNewPtr == oldPtr) { + do { AnnotateMozCrashReason("MOZ_CRASH(" "Logic flaw in the caller" ")"); do { *((volatile int*) __null) = 41; ::abort(); } while (0); } while (0); + } + + mRawPtr = aNewPtr; + delete oldPtr; + } + + + + + + + class Ptr + { + public: + Ptr(T* aPtr) + : mPtr(aPtr) + { + } + + operator T*() const + { + return mPtr; + } + + private: + T* mPtr; + }; + +private: + T* mRawPtr; + +public: + typedef T element_type; + + ~nsAutoPtr() + { + delete mRawPtr; + } + + + + nsAutoPtr() + : mRawPtr(0) + + { + } + + nsAutoPtr(Ptr aRawPtr) + : mRawPtr(aRawPtr) + + { + } + + + + nsAutoPtr(nsAutoPtr& aSmartPtr) + : mRawPtr(aSmartPtr.forget()) + + { + } + + template + nsAutoPtr(nsAutoPtr& aSmartPtr) + : mRawPtr(aSmartPtr.forget()) + + { + } + + nsAutoPtr(nsAutoPtr&& aSmartPtr) + : mRawPtr(aSmartPtr.forget()) + + { + } + + template + nsAutoPtr(nsAutoPtr&& aSmartPtr) + : mRawPtr(aSmartPtr.forget()) + + { + } + + + + nsAutoPtr& + operator=(T* aRhs) + + { + assign(aRhs); + return *this; + } + + nsAutoPtr& operator=(nsAutoPtr& aRhs) + + { + assign(aRhs.forget()); + return *this; + } + + template + nsAutoPtr& operator=(nsAutoPtr& aRhs) + + { + assign(aRhs.forget()); + return *this; + } + + nsAutoPtr& operator=(nsAutoPtr&& aRhs) + { + assign(aRhs.forget()); + return *this; + } + + template + nsAutoPtr& operator=(nsAutoPtr&& aRhs) + { + assign(aRhs.forget()); + return *this; + } + + + + T* + get() const + + + + + + { + return mRawPtr; + } + + operator T*() const +# 184 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAutoPtr.h" + { + return get(); + } + + T* + forget() + { + T* temp = mRawPtr; + mRawPtr = 0; + return temp; + } + + T* + operator->() const + { + do { } while(0); + + return get(); + } + + template + class Proxy + { + typedef R (T::*member_function)(Args...); + T* mRawPtr; + member_function mFunction; + public: + Proxy(T* aRawPtr, member_function aFunction) + : mRawPtr(aRawPtr), + mFunction(aFunction) + { + } + template + R operator()(ActualArgs&&... aArgs) + { + return ((*mRawPtr).*mFunction)(mozilla::Forward(aArgs)...); + } + }; + + template + Proxy operator->*(R (C::*aFptr)(Args...)) const + { + do { } while(0); + + return Proxy(get(), aFptr); + } + + nsAutoPtr* + get_address() + + + { + return this; + } + + const nsAutoPtr* + get_address() const + + + { + return this; + } + +public: + T& + operator*() const + { + do { } while(0); + + return *get(); + } + + T** + StartAssignment() + { + + return reinterpret_cast(begin_assignment()); + + + + + } +}; + +template +inline nsAutoPtr* +address_of(nsAutoPtr& aPtr) +{ + return aPtr.get_address(); +} + +template +inline const nsAutoPtr* +address_of(const nsAutoPtr& aPtr) +{ + return aPtr.get_address(); +} + +template +class nsAutoPtrGetterTransfers +# 301 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAutoPtr.h" +{ +public: + explicit + nsAutoPtrGetterTransfers(nsAutoPtr& aSmartPtr) + : mTargetSmartPtr(aSmartPtr) + { + + } + + operator void**() + { + return reinterpret_cast(mTargetSmartPtr.StartAssignment()); + } + + operator T**() + { + return mTargetSmartPtr.StartAssignment(); + } + + T*& + operator*() + { + return *(mTargetSmartPtr.StartAssignment()); + } + +private: + nsAutoPtr& mTargetSmartPtr; +}; + +template +inline nsAutoPtrGetterTransfers +getter_Transfers(nsAutoPtr& aSmartPtr) + + + + +{ + return nsAutoPtrGetterTransfers(aSmartPtr); +} + + + + + +template +inline bool +operator==(const nsAutoPtr& aLhs, const nsAutoPtr& aRhs) +{ + return static_cast(aLhs.get()) == static_cast(aRhs.get()); +} + + +template +inline bool +operator!=(const nsAutoPtr& aLhs, const nsAutoPtr& aRhs) +{ + return static_cast(aLhs.get()) != static_cast(aRhs.get()); +} + + + + +template +inline bool +operator==(const nsAutoPtr& aLhs, const U* aRhs) +{ + return static_cast(aLhs.get()) == static_cast(aRhs); +} + +template +inline bool +operator==(const U* aLhs, const nsAutoPtr& aRhs) +{ + return static_cast(aLhs) == static_cast(aRhs.get()); +} + +template +inline bool +operator!=(const nsAutoPtr& aLhs, const U* aRhs) +{ + return static_cast(aLhs.get()) != static_cast(aRhs); +} + +template +inline bool +operator!=(const U* aLhs, const nsAutoPtr& aRhs) +{ + return static_cast(aLhs) != static_cast(aRhs.get()); +} + +template +inline bool +operator==(const nsAutoPtr& aLhs, U* aRhs) +{ + return static_cast(aLhs.get()) == const_cast(aRhs); +} + +template +inline bool +operator==(U* aLhs, const nsAutoPtr& aRhs) +{ + return const_cast(aLhs) == static_cast(aRhs.get()); +} + +template +inline bool +operator!=(const nsAutoPtr& aLhs, U* aRhs) +{ + return static_cast(aLhs.get()) != const_cast(aRhs); +} + +template +inline bool +operator!=(U* aLhs, const nsAutoPtr& aRhs) +{ + return const_cast(aLhs) != static_cast(aRhs.get()); +} + + + + + +template +inline bool +operator==(const nsAutoPtr& aLhs, decltype(nullptr)) +{ + return aLhs.get() == nullptr; +} + +template +inline bool +operator==(decltype(nullptr), const nsAutoPtr& aRhs) +{ + return nullptr == aRhs.get(); +} + +template +inline bool +operator!=(const nsAutoPtr& aLhs, decltype(nullptr)) +{ + return aLhs.get() != nullptr; +} + +template +inline bool +operator!=(decltype(nullptr), const nsAutoPtr& aRhs) +{ + return nullptr != aRhs.get(); +} +# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OwningNonNull.h" 2 + + +namespace mozilla { + +template +class OwningNonNull +{ +public: + OwningNonNull() {} + + OwningNonNull(T& aValue) + { + init(&aValue); + } + + template + OwningNonNull(already_AddRefed&& aValue) + { + init(aValue); + } + + template + OwningNonNull(const OwningNonNull& aValue) + { + init(aValue); + } + + + operator T&() const + { + do { } while (0); + do { } while (0); + return *mPtr; + } + + operator T*() const + { + do { } while (0); + do { } while (0); + return mPtr; + } + + + explicit operator bool() const = delete; + + T* + operator->() const + { + do { } while (0); + do { } while (0); + return mPtr; + } + + OwningNonNull& + operator=(T* aValue) + { + init(aValue); + return *this; + } + + OwningNonNull& + operator=(T& aValue) + { + init(&aValue); + return *this; + } + + template + OwningNonNull& + operator=(already_AddRefed&& aValue) + { + init(aValue); + return *this; + } + + template + OwningNonNull& + operator=(const OwningNonNull& aValue) + { + init(aValue); + return *this; + } + + + void operator=(decltype(nullptr)) = delete; + + already_AddRefed forget() + { + + + + return mPtr.forget(); + } + + template + void + forget(U** aOther) + { + + + + mPtr.forget(aOther); + } + + + T* get() const + { + do { } while (0); + do { } while (0); + return mPtr; + } + + template + void swap(U& aOther) + { + mPtr.swap(aOther); + + + + } + + + + + bool isInitialized() const + { + do { } while (0); + return mPtr; + } + +protected: + template + void init(U&& aValue) + { + mPtr = aValue; + do { } while (0); + + + + } + + RefPtr mPtr; + + + +}; + +template +inline void +ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback, + OwningNonNull& aField, + const char* aName, + uint32_t aFlags = 0) +{ + CycleCollectionNoteChild(aCallback, aField.get(), aName, aFlags); +} + +} + + +template template +nsCOMPtr::nsCOMPtr(const mozilla::OwningNonNull& aOther) + : nsCOMPtr(aOther.get()) +{} + +template template +nsCOMPtr& +nsCOMPtr::operator=(const mozilla::OwningNonNull& aOther) +{ + return operator=(aOther.get()); +} + + +template template +RefPtr::RefPtr(const mozilla::OwningNonNull& aOther) + : RefPtr(aOther.get()) +{} + +template template +RefPtr& +RefPtr::operator=(const mozilla::OwningNonNull& aOther) +{ + return operator=(aOther.get()); +} +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RootedOwningNonNull.h" 2 + + + +namespace JS { +template +struct GCPolicy> +{ + typedef mozilla::OwningNonNull SmartPtrType; + + static SmartPtrType initial() + { + return SmartPtrType(); + } + + static void trace(JSTracer* trc, SmartPtrType* tp, + const char* name) + { +# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RootedOwningNonNull.h" + if ((*tp).isInitialized()) { + (*tp)->Trace(trc); + } + } +}; +} + +namespace js { +template +struct WrappedPtrOperations, Wrapper> +{ + operator T& () const + { + return static_cast(this)->get(); + } +}; +} +# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingDeclarations.h" 2 +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RootedRefPtr.h" 1 +# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RootedRefPtr.h" +namespace JS { +template +struct GCPolicy> +{ + static RefPtr initial() { + return RefPtr(); + } + + static void trace(JSTracer* trc, RefPtr* tp, const char* name) + { + if (*tp) { + (*tp)->Trace(trc); + } + } +}; +} + +namespace js { +template +struct WrappedPtrOperations, Wrapper> +{ + operator T*() const + { + return static_cast(this)->get(); + } +}; +} +# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingDeclarations.h" 2 + +# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMString.h" 1 +# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMString.h" +namespace mozilla { +namespace dom { +# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMString.h" +class DOMString { +public: + DOMString() + : mStringBuffer(nullptr) + , mLength(0) + , mIsNull(false) + , mStringBufferOwned(false) + {} + ~DOMString() + { + do { } while (0); + + if (mStringBufferOwned) { + do { } while (0); + mStringBuffer->Release(); + } + } + + operator nsString&() + { + return AsAString(); + } + + + + operator const nsString&() = delete; + operator const nsAString&() = delete; + + nsString& AsAString() + { + do { } while (0); + do { } while (0); + if (!mString) { + mString.emplace(); + } + return *mString; + } + + bool HasStringBuffer() const + { + do { } while (0); + + do { } while (0); + return !mString; + } + + + + + + + nsStringBuffer* StringBuffer() const + { + do { } while (0); + do { } while (0); + + do { } while (0); + do { } while (0); + + return mStringBuffer; + } + + + + uint32_t StringBufferLength() const + { + do { } while (0); + return mLength; + } + + + + void RelinquishBufferOwnership() + { + do { } while (0); + if (mStringBufferOwned) { + + mStringBufferOwned = false; + } else { + + mStringBuffer->AddRef(); + } + } + + + + + void SetStringBuffer(nsStringBuffer* aStringBuffer, uint32_t aLength) + { + do { } while (0); + do { } while (0); + do { } while (0); + do { } while (0); + mStringBuffer = aStringBuffer; + mLength = aLength; + } + + + void SetEphemeralStringBuffer(nsStringBuffer* aStringBuffer, uint32_t aLength) + { + + SetStringBuffer(aStringBuffer, aLength); + aStringBuffer->AddRef(); + mStringBufferOwned = true; + } + + void SetOwnedString(const nsAString& aString) + { + do { } while (0); + do { } while (0); + do { } while (0); + nsStringBuffer* buf = nsStringBuffer::FromString(aString); + if (buf) { + SetStringBuffer(buf, aString.Length()); + } else if (aString.IsVoid()) { + SetNull(); + } else if (!aString.IsEmpty()) { + AsAString() = aString; + } + } + + enum NullHandling + { + eTreatNullAsNull, + eTreatNullAsEmpty, + eNullNotExpected + }; + + void SetOwnedAtom(nsIAtom* aAtom, NullHandling aNullHandling) + { + do { } while (0); + do { } while (0); + do { } while (0); + do { } while (0); + if (aNullHandling == eNullNotExpected || aAtom) { + SetStringBuffer(aAtom->GetStringBuffer(), aAtom->GetLength()); + } else if (aNullHandling == eTreatNullAsNull) { + SetNull(); + } + } + + void SetNull() + { + do { } while (0); + do { } while (0); + mIsNull = true; + } + + bool IsNull() const + { + do { } while (0); + + return mIsNull || (mString && mString->IsVoid()); + } + + void ToString(nsAString& aString) + { + if (IsNull()) { + SetDOMStringToNull(aString); + } else if (HasStringBuffer()) { + if (StringBufferLength() == 0) { + aString.Truncate(); + } else { + + + nsStringBuffer* buf = StringBuffer(); + uint32_t len = StringBufferLength(); + auto chars = static_cast(buf->Data()); + if (chars[len] == '\0') { + + buf->ToString(len, aString); + } else { + + aString.Assign(chars, len); + } + } + } else { + aString = AsAString(); + } + } + +private: + + Maybe mString; + + + + nsStringBuffer* mStringBuffer; + + + uint32_t mLength; + bool mIsNull; + bool mStringBufferOwned; +}; + +} +} +# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingDeclarations.h" 2 + + + + + +class nsIPrincipal; +class nsWrapperCache; + +namespace mozilla { +namespace dom { + + + +struct DictionaryBase +{ +protected: + bool ParseJSON(JSContext* aCx, const nsAString& aJSON, + JS::MutableHandle aVal); + + bool StringifyToJSON(JSContext* aCx, + JS::Handle aObj, + nsAString& aJSON) const; + + + + + + struct FastDictionaryInitializer { + }; + + bool mIsAnyMemberPresent = false; + +private: + + + static bool AppendJSONToString(const char16_t* aJSONData, + uint32_t aDataLength, void* aString); + +public: + bool IsAnyMemberPresent() const + { + return mIsAnyMemberPresent; + } +}; + + + + +struct AllTypedArraysBase { +}; + + + + +struct AllOwningUnionBase { +}; + + +struct EnumEntry { + const char* value; + size_t length; +}; + +enum class CallerType : uint32_t; + +class GlobalObject +{ +public: + GlobalObject(JSContext* aCx, JSObject* aObject); + + JSObject* Get() const + { + return mGlobalJSObject; + } + + nsISupports* GetAsSupports() const; + + + + + JSContext* Context() const + { + return mCx; + } + + bool Failed() const + { + return !Get(); + } + + + + nsIPrincipal* GetSubjectPrincipal() const; + + + + dom::CallerType CallerType() const; + +protected: + JS::Rooted mGlobalJSObject; + JSContext* mCx; + mutable nsISupports* mGlobalObject; + + + +}; + + +template +class Optional_base +{ +public: + Optional_base() + {} + + explicit Optional_base(const T& aValue) + { + mImpl.emplace(aValue); + } + + bool operator==(const Optional_base& aOther) const + { + return mImpl == aOther.mImpl; + } + + template + explicit Optional_base(const T1& aValue1, const T2& aValue2) + { + mImpl.emplace(aValue1, aValue2); + } + + bool WasPassed() const + { + return mImpl.isSome(); + } + + + template + InternalType& Construct(Args&&... aArgs) + { + mImpl.emplace(Forward(aArgs)...); + return *mImpl; + } + + void Reset() + { + mImpl.reset(); + } + + const T& Value() const + { + return *mImpl; + } + + + InternalType& Value() + { + return *mImpl; + } + + + const InternalType& InternalValue() const + { + return *mImpl; + } + + + + + +private: + + Optional_base(const Optional_base& other) = delete; + const Optional_base &operator=(const Optional_base &other) = delete; + +protected: + Maybe mImpl; +}; + +template +class Optional : public Optional_base +{ +public: + Optional() : + Optional_base() + {} + + explicit Optional(const T& aValue) : + Optional_base(aValue) + {} +}; + +template +class Optional > : + public Optional_base, JS::Rooted > +{ +public: + Optional() : + Optional_base, JS::Rooted >() + {} + + explicit Optional(JSContext* cx) : + Optional_base, JS::Rooted >() + { + this->Construct(cx); + } + + Optional(JSContext* cx, const T& aValue) : + Optional_base, JS::Rooted >(cx, aValue) + {} + + + + JS::Handle Value() const + { + return *this->mImpl; + } + + + + JS::Rooted& Value() + { + return *this->mImpl; + } +}; + + + + +template<> +class Optional : public Optional_base +{ +public: + Optional() : + Optional_base() + {} + + explicit Optional(JSObject* aValue) : + Optional_base(aValue) + {} + + + JSObject*& Construct() + { + + + return Optional_base::Construct( + static_cast(nullptr)); + } + + template + JSObject*& Construct(const T1& t1) + { + return Optional_base::Construct(t1); + } +}; + + +template<> +class Optional +{ +private: + Optional() = delete; + + explicit Optional(const JS::Value& aValue) = delete; +}; + + +template class NonNull; +template +class Optional > : public Optional_base > +{ +public: + + + + T& Value() const + { + return *this->mImpl->get(); + } + + + + NonNull& Value() + { + return *this->mImpl; + } +}; + + + +template +class Optional > : public Optional_base > +{ +public: + + + + T& Value() const + { + return *this->mImpl->get(); + } + + + + OwningNonNull& Value() + { + return *this->mImpl; + } +}; + + + + + + +namespace binding_detail { +struct FakeString; +} + +template<> +class Optional +{ +public: + Optional() : mPassed(false) {} + + bool WasPassed() const + { + return mPassed; + } + + void operator=(const nsAString* str) + { + do { } while (0); + mStr = str; + mPassed = true; + } + + + + void operator=(const binding_detail::FakeString* str) + { + do { } while (0); + mStr = reinterpret_cast(str); + mPassed = true; + } + + const nsAString& Value() const + { + do { } while (0); + return *mStr; + } + +private: + + Optional(const Optional& other) = delete; + const Optional &operator=(const Optional &other) = delete; + + bool mPassed; + const nsAString* mStr; +}; + +template +class NonNull +{ +public: + NonNull() + + + + {} + + + operator T&() const { + do { } while (0); + do { } while (0); + return *ptr; + } + + operator T*() const { + do { } while (0); + do { } while (0); + return ptr; + } + + void operator=(T* t) { + ptr = t; + do { } while (0); + + + + } + + template + void operator=(U* t) { + ptr = t->ToAStringPtr(); + do { } while (0); + + + + } + + T** Slot() { + + + + return &ptr; + } + + T* Ptr() { + do { } while (0); + do { } while (0); + return ptr; + } + + + T* get() const { + do { } while (0); + do { } while (0); + return ptr; + } + +protected: + T* ptr; + + + +}; + + + + + +template +class Sequence : public FallibleTArray +{ +public: + Sequence() : FallibleTArray() + {} +}; + +inline nsWrapperCache* +GetWrapperCache(nsWrapperCache* cache) +{ + return cache; +} + +inline nsWrapperCache* +GetWrapperCache(void* p) +{ + return nullptr; +} + + + +template